LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    OceanKeyak_Instance instance;

    OceanKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    OceanKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
subq $0x388, %rsp            # imm = 0x388
movq 0x3a0(%rsp), %rax
movq 0x398(%rsp), %rax
movq 0x390(%rsp), %rax
movq %rdi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq %rdx, 0x370(%rsp)
movq %rcx, 0x368(%rsp)
movq %r8, 0x360(%rsp)
movq %r9, 0x358(%rsp)
movq 0x3a0(%rsp), %rsi
movq 0x398(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x54e0
movq 0x370(%rsp), %rsi
movq 0x380(%rsp), %rdx
movq 0x368(%rsp), %rcx
movq 0x360(%rsp), %r8
movq 0x358(%rsp), %r9
movq 0x380(%rsp), %rax
addq 0x368(%rsp), %rax
leaq 0x20(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x53f0
movq 0x368(%rsp), %rcx
addq $0x10, %rcx
movq 0x378(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x388, %rsp            # imm = 0x388
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    OceanKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    OceanKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( OceanKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char*)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
subq $0x398, %rsp            # imm = 0x398
movq 0x3b0(%rsp), %rax
movq 0x3a8(%rsp), %rax
movq 0x3a0(%rsp), %rax
movq %rdi, 0x388(%rsp)
movq %rsi, 0x380(%rsp)
movq %rdx, 0x378(%rsp)
movq %rcx, 0x370(%rsp)
movq %r8, 0x368(%rsp)
movq %r9, 0x360(%rsp)
cmpq $0x10, 0x368(%rsp)
jae 0x4f70a
movl $0xffffffff, 0x394(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f7dd
movq 0x3b0(%rsp), %rsi
movq 0x3a8(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x54e0
movq 0x368(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x380(%rsp), %rax
movq %rcx, (%rax)
movq 0x370(%rsp), %rsi
movq 0x388(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x360(%rsp), %r8
movq 0x3a0(%rsp), %r9
movq 0x370(%rsp), %rax
addq 0x20(%rsp), %rax
leaq 0x28(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x53f0
cmpl $0x1, %eax
jne 0x4f7d2
movl $0x0, 0x394(%rsp)
jmp 0x4f7dd
movl $0xffffffff, 0x394(%rsp) # imm = 0xFFFFFFFF
movl 0x394(%rsp), %eax
addq $0x398, %rsp            # imm = 0x398
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_02/open.c
// Function: main
int main(void)
{
	int fd;
	mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;

	/* Opens a file for writing creating the file if it does not
	 * already exist.
	 */
	fd = open(TMP_FILE, O_WRONLY | O_CREAT | O_TRUNC, mode);
	if (fd < 0)
		perror("open(O_WRONLY | O_CREAT | O_TRUNC)");
	else
		close(fd);

	/* Try to create TMP_FILE file and then to open it for writing.
	 * Thanks to the O_EXCL flag the call fails if the file already
	 * exists otherwise the file existence and creation is done
	 * atomically.
	 */
	fd = open(TMP_FILE, O_WRONLY | O_CREAT | O_EXCL, mode);
	if (fd < 0)
		perror("open(O_WRONLY | O_CREAT | O_EXCL)");
	else
		close(fd);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x1a4, -0xc(%rbp)      # imm = 0x1A4
movl -0xc(%rbp), %edx
leaq 0xe84(%rip), %rdi       # 0x2004
movl $0x241, %esi            # imm = 0x241
movb $0x0, %al
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x11a3
leaq 0xe72(%rip), %rdi       # 0x200e
callq 0x1050
jmp 0x11ab
movl -0x8(%rbp), %edi
callq 0x1030
movl -0xc(%rbp), %edx
leaq 0xe4f(%rip), %rdi       # 0x2004
movl $0xc1, %esi
movb $0x0, %al
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x11d8
leaq 0xe60(%rip), %rdi       # 0x2031
callq 0x1050
jmp 0x11e0
movl -0x8(%rbp), %edi
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/page_fault2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);
	unsigned long pgsize = getpagesize();

	assert(fd >= 0);
	assert(ftruncate(fd, MEMSIZE) == 0);
	unlink(tmpfile);

	while (1) {
		unsigned long i;

		char *c = mmap(NULL, MEMSIZE, PROT_READ|PROT_WRITE,
			       MAP_PRIVATE, fd, 0);
		assert(c != MAP_FAILED);

		for (i = 0; i < MEMSIZE; i += pgsize) {
			c[i] = 0;
			(*iterations)++;
		}

		munmap(c, MEMSIZE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1349(%rip), %rax      # 0x4310
movq %rax, -0x30(%rbp)
movq 0x1346(%rip), %rax      # 0x4318
movq %rax, -0x28(%rbp)
movq 0x1343(%rip), %rax      # 0x4320
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21b0
movl %eax, -0x34(%rbp)
callq 0x2260
cltq
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x3000
jmp 0x301f
leaq 0x128a(%rip), %rdi      # 0x4291
leaq 0x128b(%rip), %rsi      # 0x4299
movl $0x10, %edx
leaq 0x1293(%rip), %rcx      # 0x42ad
callq 0x2110
movl -0x34(%rbp), %edi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x2100
cmpl $0x0, %eax
jne 0x3033
jmp 0x3052
leaq 0x12a6(%rip), %rdi      # 0x42e0
leaq 0x1258(%rip), %rsi      # 0x4299
movl $0x11, %edx
leaq 0x1260(%rip), %rcx      # 0x42ad
callq 0x2110
leaq -0x30(%rbp), %rdi
callq 0x2080
movl -0x34(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x8000000, %esi        # imm = 0x8000000
movl $0x3, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x20d0
movq %rax, -0x50(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x50(%rbp)
je 0x308e
jmp 0x30ad
leaq 0x1267(%rip), %rdi      # 0x42fc
leaq 0x11fd(%rip), %rsi      # 0x4299
movl $0x19, %edx
leaq 0x1205(%rip), %rcx      # 0x42ad
callq 0x2110
movq $0x0, -0x48(%rbp)
cmpq $0x8000000, -0x48(%rbp) # imm = 0x8000000
jae 0x30e7
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x30b5
movq -0x50(%rbp), %rdi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x21c0
jmp 0x305b
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/main.c
// Function: yes_or_no
static inline void yes_or_no(mm_mapopt_t *opt, int64_t flag, int long_idx, const char *arg, int yes_to_set)
{
	if (yes_to_set) {
		if (strcmp(arg, "yes") == 0 || strcmp(arg, "y") == 0) opt->flag |= flag;
		else if (strcmp(arg, "no") == 0 || strcmp(arg, "n") == 0) opt->flag &= ~flag;
		else fprintf(stderr, "[WARNING]\033[1;31m option '--%s' only accepts 'yes' or 'no'.\033[0m\n", long_options[long_idx].name);
	} else {
		if (strcmp(arg, "yes") == 0 || strcmp(arg, "y") == 0) opt->flag &= ~flag;
		else if (strcmp(arg, "no") == 0 || strcmp(arg, "n") == 0) opt->flag |= flag;
		else fprintf(stderr, "[WARNING]\033[1;31m option '--%s' only accepts 'yes' or 'no'.\033[0m\n", long_options[long_idx].name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5221
movq -0x20(%rbp), %rdi
leaq 0x5157e(%rip), %rsi     # 0x566fe
callq 0x2230
cmpl $0x0, %eax
je 0x519f
movq -0x20(%rbp), %rdi
leaq 0x52f1e(%rip), %rsi     # 0x580b3
callq 0x2230
cmpl $0x0, %eax
jne 0x51af
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x521c
movq -0x20(%rbp), %rdi
leaq 0x4ffb1(%rip), %rsi     # 0x5516b
callq 0x2230
cmpl $0x0, %eax
je 0x51d9
movq -0x20(%rbp), %rdi
leaq 0x5207f(%rip), %rsi     # 0x5724e
callq 0x2230
cmpl $0x0, %eax
jne 0x51ed
movq -0x10(%rbp), %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x521a
movq 0x58e04(%rip), %rax     # 0x5dff8
movq (%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x5905e(%rip), %rax     # 0x5e260
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x514ef(%rip), %rsi     # 0x56702
movb $0x0, %al
callq 0x2250
jmp 0x521c
jmp 0x52ca
movq -0x20(%rbp), %rdi
leaq 0x514d2(%rip), %rsi     # 0x566fe
callq 0x2230
cmpl $0x0, %eax
je 0x524b
movq -0x20(%rbp), %rdi
leaq 0x52e72(%rip), %rsi     # 0x580b3
callq 0x2230
cmpl $0x0, %eax
jne 0x525f
movq -0x10(%rbp), %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x52c8
movq -0x20(%rbp), %rdi
leaq 0x4ff01(%rip), %rsi     # 0x5516b
callq 0x2230
cmpl $0x0, %eax
je 0x5289
movq -0x20(%rbp), %rdi
leaq 0x51fcf(%rip), %rsi     # 0x5724e
callq 0x2230
cmpl $0x0, %eax
jne 0x5299
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x52c6
movq 0x58d58(%rip), %rax     # 0x5dff8
movq (%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x58fb2(%rip), %rax     # 0x5e260
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x51443(%rip), %rsi     # 0x56702
movb $0x0, %al
callq 0x2250
jmp 0x52c8
jmp 0x52ca
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/misc.c
// Function: mm_err_puts
void mm_err_puts(const char *str)
{
	int ret;
	ret = puts(str);
	if (ret == EOF) {
		perror("[ERROR] failed to write the results");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x5554
leaq 0x50e5f(%rip), %rdi     # 0x563a4
callq 0x23a0
movl $0x1, %edi
callq 0x23d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/misc.c
// Function: mm_err_fwrite
void mm_err_fwrite(const void *p, size_t size, size_t nitems, FILE *fp)
{
	int ret;
	ret = fwrite(p, size, nitems, fp);
	if (ret == EOF) {
		perror("[ERROR] failed to write data");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x23e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x55ac
leaq 0x511b3(%rip), %rdi     # 0x56750
callq 0x23a0
movl $0x1, %edi
callq 0x23d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/misc.c
// Function: mm_err_fread
void mm_err_fread(void *p, size_t size, size_t nitems, FILE *fp)
{
	int ret;
	ret = fread(p, size, nitems, fp);
	if (ret == EOF) {
		perror("[ERROR] failed to read data");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x20c0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x560c
leaq 0x51170(%rip), %rdi     # 0x5676d
callq 0x23a0
movl $0x1, %edi
callq 0x23d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/options.c
// Function: mm_idxopt_init
void mm_idxopt_init(mm_idxopt_t *opt)
{
	memset(opt, 0, sizeof(mm_idxopt_t));
	opt->k = 15, opt->w = 10, opt->flag = 0;
	opt->bucket_bits = 14;
	opt->mini_batch_size = 50000000;
	opt->batch_size = 8000000000ULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x21b0
movq -0x8(%rbp), %rax
movw $0xf, (%rax)
movq -0x8(%rbp), %rax
movw $0xa, 0x2(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movw $0xe, 0x6(%rax)
movq -0x8(%rbp), %rax
movq $0x2faf080, 0x8(%rax)   # imm = 0x2FAF080
movq -0x8(%rbp), %rax
movabsq $0x1dcd65000, %rcx      # imm = 0x1DCD65000
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/options.c
// Function: mm_mapopt_update
void mm_mapopt_update(mm_mapopt_t *opt, const mm_idx_t *mi)
{
	if ((opt->flag & MM_F_SPLICE_FOR) || (opt->flag & MM_F_SPLICE_REV))
		opt->flag |= MM_F_SPLICE;
	if (opt->mid_occ <= 0) {
		opt->mid_occ = mm_idx_cal_max_occ(mi, opt->mid_occ_frac);
		if (opt->mid_occ < opt->min_mid_occ)
			opt->mid_occ = opt->min_mid_occ;
		if (opt->max_mid_occ > opt->min_mid_occ && opt->mid_occ > opt->max_mid_occ)
			opt->mid_occ = opt->max_mid_occ;
	}
	if (opt->bw_long < opt->bw) opt->bw_long = opt->bw;
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s::%.3f*%.2f] mid_occ = %d\n", __func__, realtime() - mm_realtime0, cputime() / (realtime() - mm_realtime0), opt->mid_occ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x100, %rax            # imm = 0x100
cmpq $0x0, %rax
jne 0x6a86
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x200, %rax            # imm = 0x200
cmpq $0x0, %rax
je 0x6a97
movq -0x8(%rbp), %rax
movq (%rax), %rcx
orq $0x80, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xd4(%rax)
jg 0x6b35
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movss 0xc4(%rax), %xmm0
callq 0x8d80
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd4(%rax)
movq -0x8(%rbp), %rax
movl 0xd4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xcc(%rcx), %eax
jge 0x6af3
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd4(%rax)
movq -0x8(%rbp), %rax
movl 0xd0(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xcc(%rcx), %eax
jle 0x6b33
movq -0x8(%rbp), %rax
movl 0xd4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xd0(%rcx), %eax
jle 0x6b33
movq -0x8(%rbp), %rax
movl 0xd0(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd4(%rax)
jmp 0x6b35
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x6b53
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq 0x57bb6(%rip), %rax     # 0x5e710
cmpl $0x3, (%rax)
jl 0x6bd0
movq 0x57492(%rip), %rax     # 0x5dff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x54e0
leaq 0x57dc7(%rip), %rax     # 0x5e940
subsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x5450
movsd %xmm0, -0x28(%rbp)
callq 0x54e0
movsd -0x28(%rbp), %xmm1
movq -0x20(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x18(%rbp), %xmm0
leaq 0x57d97(%rip), %rax     # 0x5e940
subsd (%rax), %xmm2
divsd %xmm2, %xmm1
movq -0x8(%rbp), %rax
movl 0xd4(%rax), %ecx
leaq 0x4fc6e(%rip), %rsi     # 0x56830
leaq 0x4fc88(%rip), %rdx     # 0x56851
movb $0x2, %al
callq 0x2250
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_init
mm_idx_t *mm_idx_init(int w, int k, int b, int flag)
{
	mm_idx_t *mi;
	if (k*2 < b) b = k * 2;
	if (w < 1) w = 1;
	mi = (mm_idx_t*)calloc(1, sizeof(mm_idx_t));
	mi->w = w, mi->k = k, mi->b = b, mi->flag = flag;
	mi->B = (mm_idx_bucket_t*)calloc(1<<b, sizeof(mm_idx_bucket_t));
	if (!(mm_dbg_flag & 1)) mi->km = km_init();
	return mi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x8(%rbp), %eax
shll %eax
cmpl -0xc(%rbp), %eax
jge 0x7bb6
movl -0x8(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0x4(%rbp)
jge 0x7bc3
movl $0x1, -0x4(%rbp)
movl $0x1, %edi
movl $0x60, %esi
callq 0x2220
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdi
movl $0x30, %esi
callq 0x2220
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
leaq 0x56d12(%rip), %rax     # 0x5e938
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x7c40
callq 0x1a820
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_index_name
int mm_idx_index_name(mm_idx_t *mi)
{
	khash_t(str) *h;
	uint32_t i;
	int has_dup = 0, absent;
	if (mi->h) return 0;
	h = kh_init(str);
	for (i = 0; i < mi->n_seq; ++i) {
		khint_t k;
		k = kh_put(str, h, mi->seq[i].name, &absent);
		if (absent) kh_val(h, k) = i;
		else has_dup = 1;
	}
	mi->h = h;
	if (has_dup && mm_verbose >= 2)
		fprintf(stderr, "[WARNING] some database sequences have identical sequence names\n");
	return has_dup;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x84ba
movl $0x0, -0x4(%rbp)
jmp 0x8564
callq 0x8570
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x8528
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq -0x24(%rbp), %rdx
callq 0x8590
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x8514
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x28(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x851b
movl $0x1, -0x20(%rbp)
jmp 0x851d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x84ca
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
cmpl $0x0, -0x20(%rbp)
je 0x855e
leaq 0x561cf(%rip), %rax     # 0x5e710
cmpl $0x2, (%rax)
jl 0x855e
movq 0x55aab(%rip), %rax     # 0x5dff8
movq (%rax), %rdi
leaq 0x4e8a8(%rip), %rsi     # 0x56dff
movb $0x0, %al
callq 0x2250
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_name2id
int mm_idx_name2id(const mm_idx_t *mi, const char *name)
{
	khash_t(str) *h = (khash_t(str)*)mi->h;
	khint_t k;
	if (h == 0) return -2;
	k = kh_get(str, h, name);
	return k == kh_end(h)? -1 : kh_val(h, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x891c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x8958
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8970
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x8941
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x8952
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_getseq
int mm_idx_getseq(const mm_idx_t *mi, uint32_t rid, uint32_t st, uint32_t en, uint8_t *seq)
{
	uint64_t i, st1, en1;
	if (rid >= mi->n_seq || st >= mi->seq[rid].len) return -1;
	if (en > mi->seq[rid].len) en = mi->seq[rid].len;
	st1 = mi->seq[rid].offset + st;
	en1 = mi->seq[rid].offset + en;
	for (i = st1; i < en1; ++i)
		seq[i - st1] = mm_seq4_get(mi->S, i);
	return en - st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x8afb
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl -0x14(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jb 0x8b07
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8bd7
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl -0x14(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jbe 0x8b39
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x8bce
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rcx
shrq $0x3, %rcx
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
andq $0x7, %rcx
shlq $0x2, %rcx
shrl %cl, %eax
andl $0xf, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
subq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8b81
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_getseq_rev
int mm_idx_getseq_rev(const mm_idx_t *mi, uint32_t rid, uint32_t st, uint32_t en, uint8_t *seq)
{
	uint64_t i, st1, en1;
	const mm_idx_seq_t *s;
	if (rid >= mi->n_seq || st >= mi->seq[rid].len) return -1;
	s = &mi->seq[rid];
	if (en > s->len) en = s->len;
	st1 = s->offset + (s->len - en);
	en1 = s->offset + (s->len - st);
	for (i = st1; i < en1; ++i) {
		uint8_t c = mm_seq4_get(mi->S, i);
		seq[en1 - i - 1] = c < 4? 3 - c : c;
	}
	return en - st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x8c1b
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl -0x14(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jb 0x8c27
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8d11
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
movq -0x48(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jbe 0x8c53
movq -0x48(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl -0x1c(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl -0x18(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x8d08
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rcx
shrq $0x3, %rcx
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
andq $0x7, %rcx
shlq $0x2, %rcx
shrl %cl, %eax
andl $0xf, %eax
movb %al, -0x49(%rbp)
movzbl -0x49(%rbp), %eax
cmpl $0x4, %eax
jge 0x8cdb
movzbl -0x49(%rbp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movl %eax, -0x50(%rbp)
jmp 0x8ce2
movzbl -0x49(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
subq -0x30(%rbp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8c91
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_build
mm_idx_t *mm_idx_build(const char *fn, int w, int k, int flag, int n_threads) // a simpler interface; deprecated
{
	mm_bseq_file_t *fp;
	mm_idx_t *mi;
	fp = mm_bseq_open(fn);
	if (fp == 0) return 0;
	mi = mm_idx_gen(fp, w, k, 14, flag, 1<<18, n_threads, UINT64_MAX);
	mm_bseq_close(fp);
	return mi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bb20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9967
movq $0x0, -0x8(%rbp)
jmp 0x99a9
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %eax
movl $0xe, %ecx
movl $0x40000, %r9d          # imm = 0x40000
movl %eax, (%rsp)
movq $-0x1, 0x8(%rsp)
callq 0x8fb0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1bbd0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_add
static void mm_idx_add(mm_idx_t *mi, int n, const mm128_t *a)
{
	int i, mask = (1<<mi->b) - 1;
	for (i = 0; i < n; ++i) {
		mm128_v *p = &mi->B[a[i].x>>8&mask].a;
		kv_push(mm128_t, 0, *p, a[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9e42
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
shrq $0x8, %rcx
movslq -0x20(%rbp), %rdx
andq %rdx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9df5
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9db6
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0x9dc1
movl $0x2, %eax
movq %rax, -0x30(%rbp)
jmp 0x9dc1
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x1ad30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9e34
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d4d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_reader_open
mm_idx_reader_t *mm_idx_reader_open(const char *fn, const mm_idxopt_t *opt, const char *fn_out)
{
	int64_t is_idx;
	mm_idx_reader_t *r;
	is_idx = mm_idx_is_idx(fn);
	if (is_idx < 0) return 0; // failed to open the index
	r = (mm_idx_reader_t*)calloc(1, sizeof(mm_idx_reader_t));
	r->is_idx = is_idx;
	if (opt) r->opt = *opt;
	else mm_idxopt_init(&r->opt);
	if (r->is_idx) {
		r->fp.idx = fopen(fn, "rb");
		r->idx_size = is_idx;
	} else r->fp.seq = mm_bseq_open(fn);
	if (fn_out) r->fp_out = fopen(fn_out, "wb");
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xad60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0xae95
movq $0x0, -0x8(%rbp)
jmp 0xaf59
movl $0x1, %edi
movl $0x38, %esi
callq 0x2220
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xaedc
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rax)
jmp 0xaee9
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x6700
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0xaf1b
movq -0x10(%rbp), %rdi
leaq 0x4c01b(%rip), %rsi     # 0x56f18
callq 0x2380
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xaf2f
movq -0x10(%rbp), %rdi
callq 0x1bb20
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
cmpq $0x0, -0x20(%rbp)
je 0xaf51
movq -0x20(%rbp), %rdi
leaq 0x4a1a8(%rip), %rsi     # 0x550e9
callq 0x2380
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_reader_close
void mm_idx_reader_close(mm_idx_reader_t *r)
{
	if (r->is_idx) fclose(r->fp.idx);
	else mm_bseq_close(r->fp.seq);
	if (r->fp_out) fclose(r->fp_out);
	free(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0xaf94
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2120
jmp 0xafa1
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1bbd0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xafb9
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2120
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_reader_read
mm_idx_t *mm_idx_reader_read(mm_idx_reader_t *r, int n_threads)
{
	mm_idx_t *mi;
	if (r->is_idx) {
		mi = mm_idx_load(r->fp.idx);
		if (mi && mm_verbose >= 2 && (mi->k != r->opt.k || mi->w != r->opt.w || (mi->flag&MM_I_HPC) != (r->opt.flag&MM_I_HPC)))
			fprintf(stderr, "[WARNING]\033[1;31m Indexing parameters (-k, -w or -H) overridden by parameters used in the prebuilt index.\033[0m\n");
	} else
		mi = mm_idx_gen(r->fp.seq, r->opt.w, r->opt.k, r->opt.bucket_bits, r->opt.flag, r->opt.mini_batch_size, n_threads, r->opt.batch_size);
	if (mi) {
		if (r->fp_out) mm_idx_dump(r->fp_out, mi);
		mi->index = r->n_parts++;
	}
	return mi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb065
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xa160
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb063
leaq 0x53709(%rip), %rax     # 0x5e710
cmpl $0x2, (%rax)
jl 0xb063
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0xb04b
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jne 0xb04b
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1, %eax
movq -0x8(%rbp), %rcx
movswl 0x14(%rcx), %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0xb063
movq 0x52fa6(%rip), %rax     # 0x5dff8
movq (%rax), %rdi
leaq 0x4bebf(%rip), %rsi     # 0x56f1b
movb $0x0, %al
callq 0x2250
jmp 0xb0b7
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movswl 0x12(%rax), %esi
movq -0x8(%rbp), %rax
movswl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movswl 0x16(%rax), %ecx
movq -0x8(%rbp), %rax
movswl 0x14(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, %r9d
movl -0xc(%rbp), %r10d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x8fb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb0f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xb0da
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e50
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_alt_read
int mm_idx_alt_read(mm_idx_t *mi, const char *fn)
{
	int n_alt = 0;
	gzFile fp;
	kstream_t *ks;
	kstring_t str = {0,0,0};
	fp = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) return -1;
	ks = ks_init(fp);
	if (mi->h == 0) mm_idx_index_name(mi);
	while (ks_getuntil(ks, KS_SEP_LINE, &str, 0) >= 0) {
		char *p;
		int id;
		for (p = str.s; *p && !isspace(*p); ++p) { }
		*p = 0;
		id = mm_idx_name2id(mi, str.s);
		if (id >= 0) mi->seq[id].is_alt = 1, ++n_alt;
	}
	mi->n_alt = n_alt;
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s] found %d ALT contigs\n", __func__, n_alt);
	return n_alt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x21b0
cmpq $0x0, -0x18(%rbp)
je 0xb1c9
movq -0x18(%rbp), %rdi
leaq 0x4c1e9(%rip), %rsi     # 0x57392
callq 0x2230
cmpl $0x0, %eax
je 0xb1c9
movq -0x18(%rbp), %rdi
leaq 0x4b6f9(%rip), %rsi     # 0x568b7
callq 0x2340
movq %rax, -0x60(%rbp)
jmp 0xb1ea
movq 0x52e08(%rip), %rax     # 0x5dfd8
movq (%rax), %rdi
callq 0x22a0
movl %eax, %edi
leaq 0x4b6d6(%rip), %rsi     # 0x568b7
callq 0x20f0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xb205
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb322
movq -0x28(%rbp), %rdi
callq 0x1b040
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0xb226
movq -0x10(%rbp), %rdi
callq 0x8490
jmp 0xb228
movq -0x30(%rbp), %rdi
movl $0x2, %esi
leaq -0x48(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xb330
cmpl $0x0, %eax
jl 0xb2e4
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x61(%rbp)
je 0xb286
callq 0x2450
movq (%rax), %rax
movq -0x50(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0xb28f
jmp 0xb29f
jmp 0xb291
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xb24f
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x88f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jl 0xb2df
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x54(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x14(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb228
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq 0x5341b(%rip), %rax     # 0x5e710
cmpl $0x3, (%rax)
jl 0xb31c
movq 0x52cf7(%rip), %rax     # 0x5dff8
movq (%rax), %rdi
movl -0x1c(%rbp), %ecx
leaq 0x4bc7b(%rip), %rsi     # 0x56f89
leaq 0x4bc92(%rip), %rdx     # 0x56fa7
movb $0x0, %al
callq 0x2250
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_jjump_merge
static mm_idx_jjump_t *mm_idx_jjump_merge(const mm_idx_t *mi, const mm_idx_jjump_t *J0, const mm_idx_jjump_t *J1)
{
	int32_t i;
	mm_idx_jjump_t *J2;
	J2 = CALLOC(mm_idx_jjump_t, mi->n_seq);
	for (i = 0; i < mi->n_seq; ++i) {
		int32_t j, k;
		const mm_idx_jjump_t *jj0 = &J0[i], *jj1 = &J1[i];
		mm_idx_jjump_t *jj2 = &J2[i];
		jj2->n = jj0->n + jj1->n;
		jj2->a = CALLOC(mm_idx_jjump1_t, jj2->n);
		for (j = k = 0; j < jj0->n; ++j) jj2->a[k++] = jj0->a[j];
		for (j = 0; j < jj1->n; ++j) jj2->a[k++] = jj1->a[j];
		sort_jjump(jj2);
	}
	return J2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
movl $0x10, %esi
callq 0x2220
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0xd30d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
addl (%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movslq (%rax), %rdi
movl $0x10, %esi
callq 0x2220
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd29b
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x30(%rbp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd247
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd2f6
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x30(%rbp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd2a2
movq -0x48(%rbp), %rdi
callq 0xed80
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd1c2
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_jump_get
const mm_idx_jjump1_t *mm_idx_jump_get(const mm_idx_t *db, int32_t cid, int32_t st, int32_t en, int32_t *n)
{
	mm_idx_jjump_t *s;
	int32_t l, r;
	*n = 0;
	if (cid >= db->n_seq || cid < 0 || db->J == 0) return 0;
	if (en < 0 || en > db->seq[cid].len) en = db->seq[cid].len;
	s = &db->J[cid];
	if (s->n == 0) return 0;
	l = mm_idx_jump_get_core(s->n, s->a, st);
	r = mm_idx_jump_get_core(s->n, s->a, en);
	*n = r - l;
	return &s->a[l + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0xd360
cmpl $0x0, -0x14(%rbp)
jl 0xd360
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xd36d
movq $0x0, -0x8(%rbp)
jmp 0xd42b
cmpl $0x0, -0x1c(%rbp)
jl 0xd38e
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jbe 0xd3a7
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xd3d1
movq $0x0, -0x8(%rbp)
jmp 0xd42b
movq -0x30(%rbp), %rax
movl (%rax), %edi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x18(%rbp), %edx
callq 0xd440
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0xd440
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
subl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_jump_get_core
static int32_t mm_idx_jump_get_core(int32_t n, const mm_idx_jjump1_t *a, int32_t x) // similar to mm_idx_find_intv()
{
	int32_t s = 0, e = n;
	if (n == 0) return -1;
	if (x < a[0].off) return -1;
	while (s < e) {
		int32_t mid = s + (e - s) / 2;
		if (x >= a[mid].off && (mid + 1 >= n || x < a[mid+1].off)) return mid;
		else if (x < a[mid].off) e = mid;
		else s = mid + 1;
	}
	assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xd471
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd545
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd488
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd545
jmp 0xd48a
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xd526
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jl 0xd4f8
movl -0x20(%rbp), %eax
addl $0x1, %eax
cmpl -0x8(%rbp), %eax
jge 0xd4f0
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0xd4f8
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd545
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0xd516
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xd51f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd521
jmp 0xd48a
leaq 0x4a17c(%rip), %rdi     # 0x576a9
leaq 0x4996d(%rip), %rsi     # 0x56ea1
movl $0x3af, %edx            # imm = 0x3AF
leaq 0x49d9a(%rip), %rcx     # 0x572da
callq 0x21a0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/index.c
// Function: mm_idx_find_intv
static int32_t mm_idx_find_intv(int32_t n, const uint64_t *a, int64_t x)
{
	int32_t s = 0, e = n;
	if (n == 0) return -1;
	if (x < a[0]>>8) return -1;
	while (s < e) {
		int32_t mid = s + (e - s) / 2;
		if (x >= a[mid]>>8 && (mid + 1 >= n || x < a[mid+1]>>8)) return mid;
		else if (x < a[mid]>>8) e = mid;
		else s = mid + 1;
	}
	assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xdd12
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xddf8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x8, %rcx
cmpq %rcx, %rax
jae 0xdd32
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xddf8
jmp 0xdd34
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xddd9
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x8, %rcx
cmpq %rcx, %rax
jb 0xdda8
movl -0x24(%rbp), %eax
addl $0x1, %eax
cmpl -0x8(%rbp), %eax
jge 0xdda0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x8, %rcx
cmpq %rcx, %rax
jae 0xdda8
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xddf8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x8, %rcx
cmpq %rcx, %rax
jae 0xddc9
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xddd2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xddd4
jmp 0xdd34
leaq 0x498c9(%rip), %rdi     # 0x576a9
leaq 0x490ba(%rip), %rsi     # 0x56ea1
movl $0x41b, %edx            # imm = 0x41B
leaq 0x4952f(%rip), %rcx     # 0x57322
callq 0x21a0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/map.c
// Function: collect_minimizers
static void collect_minimizers(void *km, const mm_mapopt_t *opt, const mm_idx_t *mi, int n_segs, const int *qlens, const char **seqs, mm128_v *mv)
{
	int i, n, sum = 0;
	mv->n = 0;
	for (i = n = 0; i < n_segs; ++i) {
		size_t j;
		mm_sketch(km, seqs[i], qlens[i], mi->w, mi->k, i, mi->flag&MM_I_HPC, mv);
		for (j = n; j < mv->n; ++j)
			mv->a[j].y += sum << 1;
		if (opt->sdust_thres > 0) // mask low-complexity minimizers
			mv->n = n + mm_dust_minier(km, mv->n - n, mv->a + n, qlens[i], seqs[i], opt->sdust_thres);
		sum += qlens[i], n = mv->n;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq 0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x10d56
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r8d
movl -0x34(%rbp), %r9d
movq -0x18(%rbp), %rax
movl 0xc(%rax), %r10d
andl $0x1, %r10d
movq 0x10(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1c6c0
movslq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x10cc1
movl -0x3c(%rbp), %eax
shll %eax
movslq %eax, %rcx
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x48(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x10c83
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x10d2d
movl -0x38(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movslq -0x38(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %r8
movq (%rax,%r8,8), %r8
movq -0x10(%rbp), %rax
movl 0xc(%rax), %r9d
callq 0x12e90
movl %eax, %ecx
movl -0x4c(%rbp), %eax
addl %ecx, %eax
movslq %eax, %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq 0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10c23
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)