LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/vi[P]simple_cbor_stream_parse/scsp_cpp.cpp
// Function: scsp::Generator::writething(unsigned char, unsigned long)
void Generator::writething(uint8_t maj, uint64_t value) {
    if (value < 24) {
        uint8_t t = value | maj;
        o.write((char*)&t, 1);
    } else
    if (value < 0x100) {
        uint8_t q = value;
        uint8_t t = 0x18 | maj;
        o.write((char*)&t, 1);
        o.write((char*)&q, 1);
    } else
    if (value < 0x10000) {
        uint8_t q[2];
        q[0] = (value & 0xFF00) >> 8;
        q[1] = (value & 0x00FF) >> 0;
        uint8_t t = 0x19 | maj;
        o.write((char*)&t, 1);
        o.write((char*)&q, 2);
    } else
    if (value < 0x100000000LL) {
        uint8_t q[4];
        q[0] = (value & 0xFF000000UL) >> 24;
        q[1] = (value & 0x00FF0000UL) >> 16;
        q[2] = (value & 0x0000FF00UL) >> 8;
        q[3] = (value & 0x000000FFUL) >> 0;
        uint8_t t = 0x1A | maj;
        o.write((char*)&t, 1);
        o.write((char*)&q, 4);
    } else {
        uint8_t t = 0x1B | maj;
        o.write((char*)&t, 1);
        int i;
        for (i=0; i<8; ++i) {
            uint8_t q = (value&0xFF00000000000000ULL) >> 56;
            value<<=8;
            o.write((char*)&q, 1);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x17, %rdx
ja 0x2473
orb %sil, %r14b
leaq 0x11(%rsp), %rsi
movb %r14b, (%rsi)
movq 0x8(%rbx), %rdi
movl $0x1, %edx
jmp 0x2528
cmpq $0xff, %r14
ja 0x24ac
leaq 0x10(%rsp), %r15
movb %r14b, (%r15)
orb $0x18, %sil
leaq 0xf(%rsp), %rax
movb %sil, (%rax)
movq 0x8(%rbx), %rdi
movl $0x1, %edx
movq %rax, %rsi
callq 0x20e0
movq 0x8(%rbx), %rdi
movl $0x1, %edx
jmp 0x2525
cmpq $0xffff, %r14           # imm = 0xFFFF
ja 0x24eb
rolw $0x8, %r14w
leaq 0x12(%rsp), %r15
movw %r14w, (%r15)
orb $0x19, %sil
leaq 0xe(%rsp), %rax
movb %sil, (%rax)
movq 0x8(%rbx), %rdi
movl $0x1, %edx
movq %rax, %rsi
callq 0x20e0
movq 0x8(%rbx), %rdi
movl $0x2, %edx
jmp 0x2525
movq %r14, %rax
shrq $0x20, %rax
jne 0x2538
bswapl %r14d
leaq 0x14(%rsp), %r15
movl %r14d, (%r15)
orb $0x1a, %sil
leaq 0xd(%rsp), %rax
movb %sil, (%rax)
movq 0x8(%rbx), %rdi
movl $0x1, %edx
movq %rax, %rsi
callq 0x20e0
movq 0x8(%rbx), %rdi
movl $0x4, %edx
movq %r15, %rsi
callq 0x20e0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
orb $0x1b, %sil
leaq 0xc(%rsp), %rax
movb %sil, (%rax)
movq 0x8(%rbx), %rdi
movl $0x1, %edx
movq %rax, %rsi
callq 0x20e0
movl $0x8, %ebp
leaq 0xb(%rsp), %r15
movq %r14, %rax
shrq $0x38, %rax
movb %al, 0xb(%rsp)
shlq $0x8, %r14
movq 0x8(%rbx), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x20e0
decl %ebp
jne 0x255f
jmp 0x252d
nop
// File: /workspace/github_c_makefile_star2_O3/vi[P]simple_cbor_stream_parse/scsp_cpp.cpp
// Function: scsp::Generator::integer(long)
void Generator::integer(SCSP_INT value) {
    if (value >= 0) {
        writething(0x00, value);
    } else {
        writething(0x20, (-value) - 1);
    }
}

// Assembly:
movq %rsi, %rdx
testq %rsi, %rsi
js 0x2595
xorl %esi, %esi
jmp 0x2444
notq %rdx
movl $0x20, %esi
jmp 0x2444
// File: /workspace/github_c_makefile_star2_O3/hifi[P]whatever/whatever.c
// Function: die
static void die(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "[whatever] ");
    vfprintf(stderr, fmt, ap);
    exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x401b7a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq $0x4c96e8, %r15         # imm = 0x4C96E8
movq (%r15), %rcx
leaq 0x97531(%rip), %rdi     # 0x4990dc
movl $0xb, %esi
movl $0x1, %edx
callq 0x412440
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x40ba70
movl $0x1, %edi
callq 0x40af40
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/test_nibbles.c
// Function: fmttime
char *fmttime(long long elapsed) {
    static char buf[64];

#ifdef HAVE_CLOCK_GETTIME_CPUTIME
    long long sec = elapsed / 1000000000;
    long long nsec = elapsed % 1000000000;
    sprintf(buf, "%lld.%09lld processor seconds", sec, nsec);
#else
    long long sec = elapsed / 1000000;
    long long usec = elapsed % 1000000;
    sprintf(buf, "%lld.%06lld wall-time seconds", sec, usec);
#endif

    return buf;
}

// Assembly:
pushq %rbx
movq %rdi, %rcx
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
movq %rdi, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
subq %rax, %rcx
leaq 0xaa6de(%rip), %rbx     # 0xb0520
leaq 0x89277(%rip), %rsi     # 0x8f0c0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x40d0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/test_nibbles.c
// Function: main
int main(int argc, char **argv) {
    int readlen = 5000;
    unsigned long count = 1000000;
    int status = 0;
    int c;

    if (argc == 1)
        printf(
"Usage: test_nibbles [-c NUM] [-r NUM] [-n|-v]...\n"
"Options:\n"
"  -c NUM  Specify number of iterations [%lu]\n"
"  -n      Run nibble2base speed tests\n"
"  -r NUM  Specify read length [%d]\n"
"  -v      Run all validation tests\n"
"", count, readlen);

    while ((c = getopt(argc, argv, "c:nr:v")) >= 0)
        switch (c) {
        case 'c':
            count = strtoul(optarg, NULL, 0);
            break;

        case 'n':
            status += time_nibble2base(readlen, count);
            break;

        case 'r':
            readlen = atoi(optarg);
            break;

        case 'v':
            status += validate_nibble2base();
            break;
        }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x1, %edi
jne 0x6aaa
leaq 0x886ce(%rip), %rdi     # 0x8f167
movl $0xf4240, %esi          # imm = 0xF4240
movl $0x1388, %edx           # imm = 0x1388
xorl %eax, %eax
callq 0x4060
leaq 0x8878a(%rip), %rdx     # 0x8f23b
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4100
testl %eax, %eax
js 0x6b46
movl $0xf4240, %r13d         # imm = 0xF4240
xorl %r14d, %r14d
movl $0x1388, %r12d          # imm = 0x1388
leaq 0x88762(%rip), %r15     # 0x8f23b
cmpl $0x71, %eax
jg 0x6af5
cmpl $0x63, %eax
je 0x6b09
cmpl $0x6e, %eax
jne 0x6b33
movl %r12d, %edi
movq %r13, %rsi
callq 0x63d7
jmp 0x6b33
cmpl $0x72, %eax
je 0x6b21
cmpl $0x76, %eax
jne 0x6b33
callq 0x5e96
addl %eax, %r14d
jmp 0x6b33
movq 0xa94b0(%rip), %rax     # 0xaffc0
movq (%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4150
movq %rax, %r13
jmp 0x6b33
movq 0xa9498(%rip), %rax     # 0xaffc0
movq (%rax), %rdi
callq 0x4800
movl %eax, %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4100
testl %eax, %eax
jns 0x6ad9
jmp 0x6b49
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/correct.c
// Function: fmc_kmer_stat
void fmc_kmer_stat(int suf_len, const fmc64_v *a)
{
	int i, n_suf = 1<<suf_len*2;
	int64_t tot = 0;
	for (i = 0; i < n_suf; ++i)
		tot += a[i].n<<1;
	fprintf(stderr, "[M::%s] %ld k-mers\n", __func__, (long)tot);
}

// Assembly:
movl %edi, %ecx
addl %edi, %ecx
pushq $0x1
popq %rdx
xorl %eax, %eax
movq (%rsi), %rdi
movl %edx, %r8d
shrl %cl, %r8d
leaq (%rax,%rdi,2), %rax
addq $0x18, %rsi
incl %edx
testl %r8d, %r8d
je 0x2428
movq 0x22bb1(%rip), %rcx     # 0x24ff8
movq (%rcx), %rdi
leaq 0x1b23f(%rip), %rsi     # 0x1d690
leaq 0x1b24c(%rip), %rdx     # 0x1d6a4
movq %rax, %rcx
xorl %eax, %eax
jmp 0x21c0
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/diff.c
// Function: fm_diff
uint64_t *fm_diff(const rld_t *eqry, const rld_t *eref, int min_k, int max_k, int min_occ, int n_threads)
{
	shared_t d;
	assert(min_k > SUF_LEN && min_k < max_k);
	d.sub = calloc((eqry->mcnt[1] + 63) / 64, 8);
	d.min_k = min_k, d.max_k = max_k, d.min_occ = min_occ, d.eref = eref, d.eqry = eqry;
	kt_for(n_threads, worker, &d, 1<<SUF_LEN*2);
	return d.sub;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
cmpl $0x6, %edx
jl 0x50eb
movl %ecx, %r12d
movl %edx, %r13d
cmpl %ecx, %edx
jge 0x50eb
movl %r8d, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rdi
addq $0x3f, %rdi
shrq $0x6, %rdi
movl $0x8, %esi
callq 0x2190
leaq 0x10(%rsp), %rbx
movq %rax, 0x20(%rbx)
movl %r13d, (%rbx)
movl %r12d, 0x4(%rbx)
movl %ebp, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
leaq 0x43(%rip), %rsi        # 0x510a
movl $0x400, %ecx            # imm = 0x400
movl 0xc(%rsp), %edi
movq %rbx, %rdx
callq 0x340c
movq 0x20(%rbx), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x180b6(%rip), %rdi     # 0x1d1a8
leaq 0x180d0(%rip), %rsi     # 0x1d1c9
leaq 0x180d0(%rip), %rcx     # 0x1d1d0
movl $0x83, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/diff.c
// Function: descend
static rldintv_t descend(const rld_t *e, int suf_len, int suf)
{
	int i;
	rldintv_t ok[6], ik;
	ik.x[0] = ik.x[1] = 0; ik.x[2] = e->mcnt[0];
	for (i = 0; i < suf_len; ++i) {
		rld_extend(e, &ik, ok, 1);
		ik = ok[(suf>>i*2&3) + 1];
	}
	return ik;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x28(%rsi), %rax
movq (%rax), %rax
movq %rax, 0x10(%rdi)
xorl %ebp, %ebp
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x4ef6
movl %ebx, %eax
movl %ebp, %ecx
sarl %cl, %eax
andl $0x3, %eax
shll $0x5, %eax
movups 0x20(%rax,%r12), %xmm0
movups 0x30(%rax,%r12), %xmm1
movups %xmm0, (%r15)
movups %xmm1, 0x10(%r15)
addl $0x2, %ebp
cmpl $0xa, %ebp
jne 0x579d
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/diff.c
// Function: collect_tips
static void collect_tips(const rld_t *e, int min_k, int min_occ, uint64_t *sub, const rldintv_t *_ik, rldintv_v *stack)
{
	stack->n = 0;
	kv_push(rldintv_t, *stack, *_ik);
	while (stack->n) {
		uint64_t k, *p, x;
		rldintv_t ik, ok[6];
		int c;
		ik = kv_pop(*stack);
		if (ik.info <= min_k && ik.x[2] < min_occ) continue;
		rld_extend(e, &ik, ok, 1);
		if (ok[0].x[2] && ik.info >= min_k) {
			for (k = 0; k < ok[0].x[2]; ++k) {
				x = k + ok[0].x[0];
				p = sub + (x>>6);
				x = 1ULL<<(x&0x3f);
				__sync_or_and_fetch(p, x);
			}
		}
		for (c = 1; c <= 4; ++c)
			if (ok[c].x[2]) {
				ok[c].info = ik.info + 1;
				kv_push(rldintv_t, *stack, ok[c]);
			}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, (%rsp)
movq $0x0, (%r9)
cmpq $0x0, 0x8(%r9)
je 0x5823
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
jmp 0x5840
movq $0x2, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movl $0x40, %esi
callq 0x2260
movq %rax, 0x10(%rbx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
shlq $0x5, %rcx
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq (%rbx), %rax
testq %rax, %rax
je 0x598d
movslq %r12d, %rbp
movslq %r15d, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x68(%rsp), %r13
movl $0x2, %r15d
movq 0x10(%rbx), %rcx
decq %rax
movq %rax, (%rbx)
movq %rax, %rdx
shlq $0x5, %rdx
movups (%rcx,%rdx), %xmm0
movups 0x10(%rcx,%rdx), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
cmpq %rbp, 0x28(%rsp)
ja 0x58bb
movq 0x8(%rsp), %rcx
cmpq %rcx, 0x20(%rsp)
jb 0x5984
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x4ef6
cmpq $0x0, 0x40(%rsp)
je 0x590a
cmpq %rbp, 0x28(%rsp)
jb 0x590a
xorl %eax, %eax
movq 0x30(%rsp), %rcx
addq %rax, %rcx
movq %rcx, %rdx
movl $0x1, %esi
shlq %cl, %rsi
shrq $0x6, %rdx
lock
orq %rsi, (%r14,%rdx,8)
incq %rax
cmpq 0x40(%rsp), %rax
jb 0x58e4
xorl %r12d, %r12d
cmpq $0x0, 0x60(%rsp,%r12)
je 0x5974
movq 0x28(%rsp), %rax
incq %rax
movq %rax, 0x68(%rsp,%r12)
movq (%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rcx
jne 0x5951
leaq (%rcx,%rcx), %rsi
testq %rcx, %rcx
cmoveq %r15, %rsi
movq %rsi, 0x8(%rbx)
shlq $0x5, %rsi
movq %rax, %rdi
callq 0x2260
movq %rax, 0x10(%rbx)
movq (%rbx), %rcx
leaq (%r12,%r13), %rdx
addq $-0x18, %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rbx)
shlq $0x5, %rcx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
addq $0x20, %r12
cmpq $0x80, %r12
jne 0x590d
movq (%rbx), %rax
testq %rax, %rax
jne 0x5880
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sub.c
// Function: worker
static void worker(void *data, long i, int tid)
{
	shared_t *d = (shared_t*)data;
	int64_t x;
	x = set_bits(d->e, d->sub, d->bits, i, d->n_threads, d->is_both);
	__sync_fetch_and_add(&d->n_ss, x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r14
movslq %esi, %r15
movq 0x28(%r14), %rax
cmpq %r15, 0x8(%rax)
movq %rdi, 0x10(%rsp)
jbe 0x5e74
movq 0x8(%rdi), %rbp
movq 0x10(%rdi), %r12
movl 0x24(%rdi), %ebx
movslq 0x20(%rdi), %r13
movq $0x0, 0x8(%rsp)
movq %r15, %rax
shrq $0x6, %rax
movq (%rbp,%rax,8), %rax
btq %r15, %rax
jae 0x5e65
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6023
testl %ebx, %ebx
je 0x5e65
movq %rax, %rcx
shrq $0x6, %rcx
movq (%rbp,%rcx,8), %rcx
btq %rax, %rcx
jb 0x5e65
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6023
incq 0x8(%rsp)
addq %r13, %r15
movq 0x28(%r14), %rax
cmpq 0x8(%rax), %r15
jb 0x5e1c
jmp 0x5e7d
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
lock
addq %rcx, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sub.c
// Function: main_sub
int main_sub(int argc, char *argv[])
{
	int c, is_comp = 0, is_both = 1, n_threads = 1;
	rld_t *e;
	uint64_t n_seqs, *sub;
	FILE *fp;

	while ((c = getopt(argc, argv, "sct:")) >= 0) {
		if (c == 'c') is_comp = 1;
		else if (c == 's') is_both = 0;
		else if (c == 't') n_threads = atoi(optarg);
	}
	if (optind + 2 > argc) {
		fprintf(stderr, "Usage: fermi2 sub [-cs] [-t nThreads=1] <reads.rld> <bits.bin>\n");
		return 1;
	}
	e = rld_restore(argv[optind]);
	fp = fopen(argv[optind+1], "rb");
	fread(&n_seqs, 8, 1, fp);
	if (n_seqs != e->mcnt[1]) {
		fprintf(stderr, "[E::%s] unmatched index and the bit array\n", __func__);
		rld_destroy(e);
		return 1;
	}
	sub = malloc((n_seqs + 63) / 64 * 8);
	fread(sub, 8, (n_seqs + 63) / 64, fp);
	fclose(fp);
	e = fm_sub(e, sub, n_threads, is_comp, is_both);
	free(sub);
	rld_dump(e, "-");
	rld_destroy(e);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl %edi, %r12d
leaq 0x1744d(%rip), %rdx     # 0x1d303
callq 0x22f0
testl %eax, %eax
js 0x5f13
movl $0x1, %r14d
xorl %ebx, %ebx
leaq 0x17435(%rip), %r13     # 0x1d303
movl $0x1, %ebp
cmpl $0x63, %eax
je 0x5efa
cmpl $0x74, %eax
je 0x5ee6
cmpl $0x73, %eax
jne 0x5eff
xorl %ebp, %ebp
jmp 0x5eff
movq 0x1f0eb(%rip), %rax     # 0x24fd8
movq (%rax), %rdi
callq 0x2300
movl %eax, %r14d
jmp 0x5eff
movl $0x1, %ebx
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x22f0
testl %eax, %eax
jns 0x5ed3
jmp 0x5f20
xorl %ebx, %ebx
movl $0x1, %ebp
movl $0x1, %r14d
movq 0x1f0a9(%rip), %r13     # 0x24fd0
movslq (%r13), %rax
leal 0x2(%rax), %ecx
cmpl %r12d, %ecx
jg 0x600d
movq (%r15,%rax,8), %rdi
callq 0x4119
movq %rax, %r12
movslq (%r13), %rax
movq 0x8(%r15,%rax,8), %rdi
leaq 0x1713e(%rip), %rsi     # 0x1d091
callq 0x22d0
movq %rax, %r15
leaq 0x10(%rsp), %r13
movl $0x8, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %rax, %rcx
callq 0x2090
movq (%r13), %r13
movq 0x28(%r12), %rax
cmpq 0x8(%rax), %r13
jne 0x6014
addq $0x3f, %r13
movq %r13, %rdi
shrq $0x3, %rdi
andq $-0x8, %rdi
callq 0x2220
movl %ebx, 0xc(%rsp)
movq %r12, %rbx
movq %rax, %r12
shrq $0x6, %r13
movl $0x8, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x2090
movq %r15, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movl 0xc(%rsp), %ecx
movl %ebp, %r8d
callq 0x59a0
movq %rax, %rbx
movq %r12, %rdi
callq 0x2040
leaq 0x17d19(%rip), %rsi     # 0x1dd05
movq %rbx, %rdi
callq 0x3f7e
movq %rbx, %rdi
callq 0x36d4
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x23e7
jmp 0x601c
movq %r12, %rdi
callq 0x23bb
movl $0x1, %eax
jmp 0x5ffe
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/sub.c
// Function: set_bits_aux
static inline int64_t set_bits_aux(const rld_t *e, uint64_t *bits, uint64_t k)
{
	int c;
	uint64_t *ok;
	ok = alloca(8 * e->asize);
	do {
		set_bit(bits, k);
		c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c == 0) break;
	} while (c);
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
movq %rcx, %rax
shrq $0x6, %rax
movl $0x1, %edx
shlq %cl, %rdx
lock
orq %rdx, (%rbx,%rax,8)
incq %rcx
movq %r14, %rdi
movq %rcx, %rsi
movq %r15, %rdx
callq 0x4895
movq 0x20(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movq (%r15,%rax,8), %rdx
addq %rdx, %rcx
decq %rcx
testl %eax, %eax
jne 0x604c
movq %rcx, %rax
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lh3[P]fermi2/unpack.c
// Function: fm_retrieve
int64_t fm_retrieve(const rld_t *e, uint64_t x, kstring_t *s)
{
	uint64_t k = x, *ok;
	ok = alloca(8 * e->asize);
	s->l = 0;
	while (1) {
		int c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c == 0) return k;
		kputc(c, s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
movl $0x0, (%rdx)
incq %rsi
movq %r15, %rdx
callq 0x4895
movl %eax, %r13d
movq 0x20(%r14), %rax
movslq %r13d, %rcx
movq (%r15,%rcx,8), %r12
addq (%rax,%rcx,8), %r12
testl %r13d, %r13d
je 0x6169
movl (%rbx), %ecx
leal 0x1(%rcx), %edx
cmpl 0x4(%rbx), %edx
jae 0x60fa
movq 0x8(%rbx), %rax
jmp 0x6133
movl %edx, %eax
shrl %eax
orl %edx, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %esi
shrl $0x10, %esi
orl %ecx, %esi
incl %esi
movl %esi, 0x4(%rbx)
movq 0x8(%rbx), %rdi
callq 0x2260
movq %rax, 0x8(%rbx)
movl (%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movl %ecx, %ecx
movb %r13b, (%rax,%rcx)
movq 0x8(%rbx), %rax
movl (%rbx), %ecx
movb $0x0, (%rax,%rcx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4895
movl %eax, %r13d
movq 0x20(%r14), %rax
movslq %r13d, %rcx
movq (%r15,%rcx,8), %r12
addq (%rax,%rcx,8), %r12
testl %ecx, %ecx
jne 0x60ea
decq %r12
movq %r12, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]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 0x173d4(%rip), %rbx     # 0x1d765
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22f0
testl %eax, %eax
jns 0x6391
movq 0x1ec27(%rip), %r15     # 0x24fd0
movslq (%r15), %rax
cmpl %ebp, %eax
je 0x6496
movq (%r14,%rax,8), %rdi
callq 0x4119
movq %rax, %rbx
movslq (%r15), %rax
leal 0x1(%rax), %ecx
cmpl %ebp, %ecx
jge 0x6454
movq 0x8(%r14,%rax,8), %rdi
leaq 0x18(%rsp), %rsi
callq 0x617e
testq %rax, %rax
je 0x649b
movq %rax, %r14
movq 0x18(%rsp), %r13
testq %r13, %r13
jle 0x644a
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 0x643a
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
movl $0xa, %edx
callq 0x21e0
movq 0x28(%rbx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x643a
movq %rbx, %rdi
movl %eax, %esi
movq %rsp, %rdx
callq 0x64af
movq %rbp, %rdi
callq 0x2040
incq %r12
cmpq %r12, %r13
jne 0x63fe
movq %r14, %rdi
callq 0x2040
jmp 0x6480
movq 0x28(%rbx), %rax
cmpq $0x0, 0x8(%rax)
je 0x6480
xorl %r14d, %r14d
movq %rsp, %r15
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x64af
incq %r14
movq 0x28(%rbx), %rax
cmpq 0x8(%rax), %r14
jb 0x6465
movq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x36d4
xorl %eax, %eax
jmp 0x64a0
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_O3/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 0x6098
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x6528
xorl %ecx, %ecx
leaq 0x16f1c(%rip), %rdx     # 0x1d3ec
movq 0x8(%r14), %rax
movsbq (%rax,%rcx), %rsi
movb (%rsi,%rdx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
movl (%r14), %eax
cmpq %rax, %rcx
jb 0x64d0
cmpl $0x2, %eax
jb 0x652a
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 0x64f8
jmp 0x652a
xorl %eax, %eax
movq 0x8(%r14), %rdi
movl %eax, %edx
movq 0x1ea89(%rip), %rax     # 0x24fc0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2310
leaq 0x17aee(%rip), %rdi     # 0x1e039
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x6948
movsd 0x16d7f(%rip), %xmm0    # 0x1d5d0
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 0x66d4
movsd %xmm0, 0x8(%rsp)
movl %ebx, %edi
movl %r15d, %esi
movsd 0x18(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq 0x66d4
movsd 0x8(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm0
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd 0x16cd5(%rip), %xmm0    # 0x1d5d0
subsd %xmm1, %xmm0
callq 0x2160
movsd 0x16cec(%rip), %xmm2    # 0x1d5f8
mulsd %xmm2, %xmm0
movsd 0x16ce8(%rip), %xmm2    # 0x1d600
addsd %xmm2, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0x29, %eax
cmovgel %ebp, %eax
shrl %eax
movb %al, (%r13,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x68a8
incq %rbx
addq %r12, %r13
cmpq %r12, %rbx
jne 0x68a5
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_O3/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, 0x8(%rsp)
movl $0x40, %edi
callq 0x2220
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x18(%rsp)
movq 0x28(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq $0x0, 0x18(%r15)
movslq %r12d, %rdi
movl $0x1, %ebx
xorl %r13d, %r13d
movl $0x2, %ebp
movq %rdi, 0x10(%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 0x6a18
movl %edx, %ecx
shrl %ecx
addb $-0x2, %cl
andb $-0x2, %cl
movl $0x3, %esi
shlq %cl, %rsi
notq %rsi
andq %rsi, %r13
movl %edx, %esi
andl $0x3, %esi
shlq %cl, %rsi
orq %rsi, %r13
shrq $0x2, %rdx
cmpq %rdi, %rdx
jne 0x6a4a
addq %r15, %rax
movq %r13, %rcx
shlq $0x5, %rcx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movq 0x8(%rsp), %rax
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq %r13, 0x18(%rax,%rcx)
jmp 0x6ae2
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movl $0x1, %ecx
callq 0x4ef6
xorl %r14d, %r14d
leaq 0x78(%rsp), %r12
cmpq $0x0, -0x8(%r12)
je 0x6ad0
movq 0x38(%rsp), %rax
andq $-0x4, %rax
addq $0x4, %rax
orq %r14, %rax
movq %rax, (%r12)
cmpq %rbp, %rbx
jne 0x6aae
leaq (%rbx,%rbx), %rbp
testq %rbx, %rbx
movl $0x2, %eax
cmoveq %rax, %rbp
movq %rbp, %rsi
shlq $0x5, %rsi
movq %r15, %rdi
callq 0x2260
movq %rax, %r15
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 0x6a6b
movq 0x10(%rsp), %rdi
testq %rbx, %rbx
jne 0x69cb
movq %r15, %rdi
callq 0x2040
movq 0x8(%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_O3/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 0x16525(%rip), %rdi     # 0x1d761
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 0x7268
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x20, %esi
callq 0x2190
movq %rax, %r14
testq %r15, %r15
jle 0x7714
xorl %ebx, %ebx
movq $0x0, 0x8(%rsp)
movq %r12, %rdi
xorl %ebp, %ebp
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
xorl %r12d, %r12d
movq %r15, 0x20(%rsp)
movq %rdi, %r13
callq 0xdf28
testl %eax, %eax
js 0x770f
cmpl 0x14(%rsp), %ebx
jge 0x762f
movq 0x8(%rsp), %rbp
jmp 0x76ac
movl %ebx, %eax
shrl %eax
orl %ebx, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rsp)
movl %ecx, 0x4(%r14)
cltq
movq %r14, %r15
leaq 0x8(,%rax,8), %r14
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2260
movq %rbp, 0x8(%rsp)
movq %rax, %rbp
movq %rax, 0x8(%r15)
movq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x2260
movq %rax, 0x10(%r15)
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %r14
movq 0x20(%rsp), %r15
callq 0x2260
movq %rax, 0x18(%r14)
movq 0x28(%r13), %rdi
callq 0x2340
movq %rax, (%rbp,%rbx,8)
cmpl $0x0, 0x30(%r13)
movq %rbp, 0x8(%rsp)
je 0x76d1
movq 0x38(%r13), %rdi
callq 0x2340
jmp 0x76d3
xorl %eax, %eax
movq 0x10(%r14), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, (%rdx,%rbx,8)
movq 0x8(%r13), %rdi
callq 0x2340
movq %r13, %rdi
movq 0x18(%r14), %rbp
leaq 0x1(%rbx), %rcx
movl %ecx, (%r14)
movq %rax, (%rbp,%rbx,8)
movl 0x20(%r13), %eax
addq %rax, %r12
movq %rcx, %rbx
cmpq %r15, %r12
jl 0x7612
testq %r12, %r12
jne 0x771f
movq %r14, %rdi
callq 0x2040
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7772
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 0x7740
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_O3/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 0x781a
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 0x78d2
movq (%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
leaq 0x1d9a8(%rip), %rdx     # 0x251e0
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 0x788d
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 0x784b
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_O3/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 0x7952
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, %rdi
movq %rax, 0x10(%r14)
jmp 0x7956
movq 0x10(%r14), %rdi
movq $0x0, (%r14)
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
callq 0x21f0
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x79c5
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x10(%rbx), %rsi
movzwl (%rsi,%rax), %edi
andl $0xf0, %edi
cmpw $0x30, %di
je 0x79b9
addq %rax, %rsi
movq (%r14), %rdx
movq 0x10(%r14), %rdi
leaq 0x1(%rdx), %r8
movq %r8, (%r14)
leaq (%rdx,%rdx,2), %rdx
movl 0x8(%rsi), %r8d
movl %r8d, 0x8(%rdi,%rdx,4)
movq (%rsi), %rsi
movq %rsi, (%rdi,%rdx,4)
movq (%rbx), %rdx
incq %rcx
addq $0xc, %rax
cmpq %rcx, %rdx
ja 0x797d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8bf2
testq %rax, %rax
je 0x8bee
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
movq 0x10(%rsi), %r9
movzwl (%r9,%rcx), %r11d
testb $-0x10, %r11b
je 0x8bdc
movq 0x10(%rdi), %r8
leaq (%r8,%rcx), %rbx
movzwl (%rbx), %r10d
testb $-0x10, %r10b
je 0x8b89
movl %r10d, %ebx
xorl %r11d, %ebx
testb $0xf, %bl
je 0x8b9c
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 0x8bdc
addq %rcx, %r9
movl 0x8(%r9), %r8d
movl %r8d, 0x8(%rbx)
movq (%r9), %r8
movq %r8, (%rbx)
jmp 0x8bdc
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 0x8b2b
jmp 0x8bf0
xorl %eax, %eax
popq %rbx
retq
leaq 0x14c2e(%rip), %rdi     # 0x1d827
leaq 0x14acb(%rip), %rsi     # 0x1d6cb
leaq 0x14c2f(%rip), %rcx     # 0x1d836
movl $0x354, %edx            # imm = 0x354
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x4, 0x1ab8a(%rip)     # 0x251d0
jg 0xa687
movslq %ecx, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq (,%r14,8), %rcx
movq 0x18(%rbx), %rdx
addq %rcx, %rdx
addq 0x20(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %r8
leaq (%r14,%r14,4), %r9
shlq $0x3, %r9
addq 0x28(%rbx), %r9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8c11
movq 0x1a96a(%rip), %rax     # 0x24ff8
movq (%rax), %rdi
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rsi
movq (%rax,%r14,8), %rdx
movslq %ecx, %r15
movq (%rsi,%r15,8), %rax
movq 0x80(%rax), %r8
movq 0x98(%rax), %r9
movq 0xa8(%rax), %rax
movl (%rax), %eax
movl %eax, (%rsp)
leaq 0x136d9(%rip), %rsi     # 0x1dd9e
xorl %eax, %eax
callq 0x21c0
jmp 0xa64b
// File: /workspace/github_c_makefile_star2_O3/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 0xccdf
movl $0xfffffffe, %r11d      # imm = 0xFFFFFFFE
roll %cl, %r11d
andl %r11d, (%r9)
addq %r10, %rdx
incq %rcx
cmpq $0x6, %rcx
jne 0xccc6
cmpl %eax, 0x8(%rdi)
jle 0xccf1
retq
leaq 0x1133f(%rip), %rdi     # 0x1e037
xorl %eax, %eax
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O3/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, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movq %rdi, %r15
callq 0x4fe7
movsd %xmm0, 0x10(%rsp)
movq (%r15), %rax
testq %rax, %rax
je 0x14017
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %edi, %edi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %esi
movq 0x10(%r15), %rbp
movl (%rbp,%r13), %ecx
testl %ecx, %ecx
js 0x13fe3
cmpq $0x0, 0x20(%rbp,%r13)
je 0x13f98
cmpl %esi, %ecx
jge 0x13fe3
cmpq $0x0, 0x38(%rbp,%r13)
je 0x13f9c
jmp 0x13fe3
cmpl %esi, %ecx
jge 0x13fe3
cmpl %edx, 0x4(%rbp,%r13)
jge 0x13fe3
cmpq %rdi, %r14
jne 0x13fd9
movq %r12, %rdi
leaq (%r14,%r14), %r12
testq %r14, %r14
movl $0x2, %eax
cmoveq %rax, %r12
leaq (,%r12,8), %rsi
callq 0x2260
movq %r12, %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq %rax, %r12
movq (%r15), %rax
addq %r13, %rbp
movq %rbp, (%r12,%r14,8)
incq %r14
incq %rbx
addq $0x68, %r13
cmpq %rbx, %rax
ja 0x13f75
movq %r14, %rdi
movq %r12, %rsi
callq 0x130df
testq %r14, %r14
je 0x14028
xorl %ebx, %ebx
movq (%r12,%rbx,8), %rsi
movq %r15, %rdi
callq 0x125cf
incq %rbx
cmpq %rbx, %r14
jne 0x14001
jmp 0x1402b
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
callq 0x130df
xorl %r12d, %r12d
jmp 0x1402b
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x2040
leaq 0x11226(%rip), %rax     # 0x25260
cmpl $0x3, (%rax)
jge 0x14051
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10fa0(%rip), %rax     # 0x24ff8
movq (%rax), %r15
callq 0x4fe7
subsd 0x10(%rsp), %xmm0
leaq 0xa39e(%rip), %rsi      # 0x1e40b
leaq 0xa3d6(%rip), %rdx      # 0x1e44a
movq %r15, %rdi
movq %r14, %rcx
movl 0x8(%rsp), %r8d
movl 0xc(%rsp), %r9d
movb $0x1, %al
callq 0x21c0
jmp 0x1403f
// File: /workspace/github_c_makefile_star2_O3/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, %ebx
movl %edx, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %r12
callq 0x4fe7
movsd %xmm0, 0x10(%rsp)
movq (%r12), %rax
testq %rax, %rax
je 0x14174
movl %ebx, 0xc(%rsp)
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %r8d, %r8d
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edi
movq 0x10(%r12), %rbp
movl (%rbp,%rbx), %ecx
testl %ecx, %ecx
sets %dl
cmpl %edi, %ecx
setge %cl
orb %dl, %cl
jne 0x14139
cmpl %esi, 0x4(%rbp,%rbx)
jge 0x14139
cmpq %r8, %r14
jne 0x1412e
movq %r13, %rdi
leaq (%r14,%r14), %r13
testq %r14, %r14
movl $0x2, %eax
cmoveq %rax, %r13
leaq (,%r13,8), %rsi
callq 0x2260
movq %r13, %r8
movl 0x4(%rsp), %edi
movl 0x8(%rsp), %esi
movq %rax, %r13
movq (%r12), %rax
addq %rbx, %rbp
movq %rbp, (%r13,%r14,8)
incq %r14
incq %r15
addq $0x68, %rbx
cmpq %r15, %rax
ja 0x140da
movq %r14, %rdi
movq %r13, %rsi
callq 0x130df
testq %r14, %r14
je 0x14185
xorl %ebx, %ebx
movl 0xc(%rsp), %ebp
movq (%r13,%rbx,8), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0x126d1
incq %rbx
cmpq %rbx, %r14
jne 0x1415b
jmp 0x14188
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
callq 0x130df
xorl %r13d, %r13d
jmp 0x14188
xorl %r14d, %r14d
movq %r13, %rdi
callq 0x2040
leaq 0x110c9(%rip), %rax     # 0x25260
cmpl $0x3, (%rax)
jge 0x141ae
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10e43(%rip), %rax     # 0x24ff8
movq (%rax), %r15
callq 0x4fe7
subsd 0x10(%rsp), %xmm0
leaq 0xa28e(%rip), %rsi      # 0x1e458
leaq 0xa2d3(%rip), %rdx      # 0x1e4a4
movq %r15, %rdi
movq %r14, %rcx
movl 0x4(%rsp), %r8d
movl 0x8(%rsp), %r9d
movb $0x1, %al
callq 0x21c0
jmp 0x1419c
// File: /workspace/github_c_makefile_star2_O3/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 0x7a73(%rip), %rdx      # 0x1eba2
callq 0x22f0
testl %eax, %eax
js 0x171df
movl $0x1, (%rsp)
movl $0x1f, 0x4(%rsp)
xorl %r14d, %r14d
movq 0xde83(%rip), %rbx      # 0x24fd8
leaq 0x7a46(%rip), %r13      # 0x1eba2
xorl %ebp, %ebp
cmpl $0x6c, %eax
jg 0x1717b
cmpl $0x4d, %eax
je 0x17192
cmpl $0x6c, %eax
jne 0x171a4
movq (%rbx), %rdi
callq 0x2300
movl %eax, 0x4(%rsp)
jmp 0x171a4
cmpl $0x6d, %eax
je 0x17199
cmpl $0x74, %eax
jne 0x171a4
movq (%rbx), %rdi
callq 0x2300
movl %eax, (%rsp)
jmp 0x171a4
movl $0x1, %ebp
jmp 0x171a4
movq (%rbx), %rdi
callq 0x2300
movl %eax, %r14d
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x22f0
testl %eax, %eax
jns 0x1715e
movq 0xde13(%rip), %rax      # 0x24fd0
movl (%rax), %eax
cmpl %r12d, %eax
jge 0x17235
testl %ebp, %ebp
movl 0x4(%rsp), %ebx
je 0x171fc
cltq
movq (%r15,%rax,8), %rdi
callq 0x4598
movq %rax, %r15
movl (%rsp), %ebp
jmp 0x1720d
movq 0xddea(%rip), %rax      # 0x24fd0
movl (%rax), %eax
xorl %r14d, %r14d
movl $0x1f, %ebx
movl $0x1, %ebp
cmpl %r12d, %eax
jl 0x171ff
jmp 0x17239
movl (%rsp), %ebp
cltq
movq (%r15,%rax,8), %rdi
callq 0x4119
movq %rax, %r15
movq %r15, %rdi
movl %ebx, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x169cc
movq %r15, %rdi
callq 0x36d4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %ebx
movl %ebx, %edi
movl %r14d, %esi
callq 0x2e8e
movl $0x1, %eax
jmp 0x17226