LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/map.c
// Function: chain_post
static void chain_post(const mm_mapopt_t *opt, int max_chain_gap_ref, const mm_idx_t *mi, void *km, int qlen, int n_segs, const int *qlens, int *n_regs, mm_reg1_t *regs, mm128_t *a)
{
	if (!(opt->flag & MM_F_ALL_CHAINS)) { // don't choose primary mapping(s)
		mm_set_parent(km, opt->mask_level, opt->mask_len, *n_regs, regs, opt->a * 2 + opt->b, opt->flag&MM_F_HARD_MLEVEL, opt->alt_drop);
		if (n_segs <= 1) mm_select_sub(km, opt->pri_ratio, mi->k*2, opt->best_n, 1, opt->max_gap * 0.8, n_regs, regs);
		else mm_select_sub_multi(km, opt->pri_ratio, 0.2f, 0.7f, max_chain_gap_ref, mi->k*2, opt->best_n, n_segs, qlens, n_regs, regs);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x800000, %rax         # imm = 0x800000
cmpq $0x0, %rax
jne 0x1189a
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movss 0x50(%rax), %xmm0
movq -0x8(%rbp), %rax
movl 0x54(%rax), %esi
movq 0x18(%rbp), %rax
movl (%rax), %edx
movq 0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x64(%rax), %r8d
shll %r8d
movq -0x8(%rbp), %rax
addl 0x68(%rax), %r8d
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
movl %eax, %r9d
movq -0x8(%rbp), %rax
movss 0x60(%rax), %xmm1
callq 0x2a3b0
cmpl $0x1, -0x28(%rbp)
jg 0x1184a
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movss 0x58(%rax), %xmm0
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
shll %esi
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %edx
movq -0x8(%rbp), %rax
cvtsi2sdl 0x1c(%rax), %xmm1
movsd 0x45b3f(%rip), %xmm2    # 0x57368
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %r8d
movq 0x18(%rbp), %r9
movq 0x20(%rbp), %rax
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x2b020
jmp 0x11898
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movss 0x58(%rax), %xmm0
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
shll %edx
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
movl -0x28(%rbp), %r8d
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
movss 0x45aee(%rip), %xmm1    # 0x57370
movss 0x4377a(%rip), %xmm2    # 0x55004
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x17f70
jmp 0x1189a
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/map.c
// Function: align_regs
static mm_reg1_t *align_regs(const mm_mapopt_t *opt, const mm_idx_t *mi, void *km, int qlen, const char *seq, int *n_regs, mm_reg1_t *regs, mm128_t *a)
{
	if (!(opt->flag & MM_F_CIGAR)) return regs;
	regs = mm_align_skeleton(km, opt, mi, qlen, seq, n_regs, regs, a); // this calls mm_filter_regs()
	if (!(opt->flag & MM_F_ALL_CHAINS)) { // don't choose primary mapping(s)
		mm_set_parent(km, opt->mask_level, opt->mask_len, *n_regs, regs, opt->a * 2 + opt->b, opt->flag&MM_F_HARD_MLEVEL, opt->alt_drop);
		mm_select_sub(km, opt->pri_ratio, mi->k*2, opt->best_n, 0, opt->max_gap * 0.8, n_regs, regs);
		mm_set_sam_pri(*n_regs, regs);
	}
	return regs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x4, %rax
cmpq $0x0, %rax
jne 0x118e5
movq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x119dd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq 0x18(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x22c20
movq %rax, 0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x800000, %rax         # imm = 0x800000
cmpq $0x0, %rax
jne 0x119d5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x50(%rax), %xmm0
movq -0x10(%rbp), %rax
movl 0x54(%rax), %esi
movq -0x38(%rbp), %rax
movl (%rax), %edx
movq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x64(%rax), %r8d
shll %r8d
movq -0x10(%rbp), %rax
addl 0x68(%rax), %r8d
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
movl %eax, %r9d
movq -0x10(%rbp), %rax
movss 0x60(%rax), %xmm1
callq 0x2a3b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x58(%rax), %xmm0
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
shll %esi
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %edx
movq -0x10(%rbp), %rax
cvtsi2sdl 0x1c(%rax), %xmm1
movsd 0x459be(%rip), %xmm2    # 0x57368
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %r8d
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x2b020
movq -0x38(%rbp), %rax
movl (%rax), %edi
movq 0x10(%rbp), %rsi
callq 0x2ada0
movq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/map.c
// Function: mm_map_frag
void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **seqs, int *n_regs, mm_reg1_t **regs, mm_tbuf_t *b, const mm_mapopt_t *opt, const char *qname)
{
	if ((opt->flag & MM_F_WEAK_PAIRING) && n_segs == 2 && opt->pe_ori >= 0 && (opt->flag&MM_F_CIGAR)) {
		int i;
		for (i = 0; i < n_segs; ++i)
			mm_map_frag_core(mi, 1, &qlens[i], &seqs[i], &n_regs[i], &regs[i], b, opt, qname);
		mm_pair(b->km, opt->max_gap_ref, opt->pe_bonus, opt->a * 2 + opt->b, opt->a, qlens, n_regs, regs);
	} else {
		mm_map_frag_core(mi, n_segs, qlens, seqs, n_regs, regs, b, opt, qname);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0x18(%rbp), %rcx
movabsq $0x4000000000, %rax     # imm = 0x4000000000
andq (%rcx), %rax
cmpq $0x0, %rax
je 0x11b30
cmpl $0x2, -0xc(%rbp)
jne 0x11b30
movq 0x18(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
jl 0x11b30
movq 0x18(%rbp), %rax
movq (%rax), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x11b30
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11ae4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movslq -0x34(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
movslq -0x34(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x28(%rbp), %r8
movslq -0x34(%rbp), %rax
shlq $0x2, %rax
addq %rax, %r8
movq -0x30(%rbp), %r9
movslq -0x34(%rbp), %rax
shlq $0x3, %rax
addq %rax, %r9
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
movl $0x1, %esi
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xf590
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11a6d
movq 0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x18(%rbp), %rax
movl 0x20(%rax), %esi
movq 0x18(%rbp), %rax
movl 0xbc(%rax), %edx
movq 0x18(%rbp), %rax
movl 0x64(%rax), %ecx
shll %ecx
movq 0x18(%rbp), %rax
addl 0x68(%rax), %ecx
movq 0x18(%rbp), %rax
movl 0x64(%rax), %r8d
movq -0x18(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x30(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x18a60
jmp 0x11b66
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xf590
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/map.c
// Function: mm_map_file_frag
int mm_map_file_frag(const mm_idx_t *idx, int n_segs, const char **fn, const mm_mapopt_t *opt, int n_threads)
{
	int i, pl_threads;
	pipeline_t pl;
	if (n_segs < 1) return -1;
	memset(&pl, 0, sizeof(pipeline_t));
	pl.n_fp = n_segs;
	pl.fp = open_bseqs(pl.n_fp, fn);
	if (pl.fp == 0) return -1;
	pl.opt = opt, pl.mi = idx;
	pl.n_threads = n_threads > 1? n_threads : 1;
	pl.mini_batch_size = opt->mini_batch_size;
	if (opt->split_prefix)
		pl.fp_split = mm_split_init(opt->split_prefix, idx);
	pl_threads = n_threads == 1? 1 : (opt->flag&MM_F_2_IO_THREADS)? 3 : 2;
	kt_pipeline(pl_threads, worker_pipeline, &pl, 3);

	free(pl.str.s);
	if (pl.fp_split) fclose(pl.fp_split);
	for (i = 0; i < pl.n_fp; ++i)
		mm_bseq_close(pl.fp[i]);
	free(pl.fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x11c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d7a
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x21b0
movl -0x14(%rbp), %eax
movl %eax, -0x98(%rbp)
movl -0x98(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x11d90
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x11c52
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d7a
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x1, -0x2c(%rbp)
jle 0x11c76
movl -0x2c(%rbp), %eax
movl %eax, -0xa4(%rbp)
jmp 0x11c83
movl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x11c83
movl -0xa4(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x28(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x100(%rax)
je 0x11cc7
movq -0x28(%rbp), %rax
movq 0x100(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x19a80
movq %rax, -0x48(%rbp)
cmpl $0x1, -0x2c(%rbp)
jne 0x11cda
movl $0x1, %eax
movl %eax, -0xa8(%rbp)
jmp 0x11cff
movq -0x28(%rbp), %rax
movq (%rax), %rdx
andq $0x8000, %rdx           # imm = 0x8000
movl $0x2, %eax
movl $0x3, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0xa8(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
leaq 0x18e(%rip), %rsi       # 0x11ea0
leaq -0xa0(%rbp), %rdx
movl $0x3, %ecx
callq 0x1a200
movq -0x60(%rbp), %rdi
callq 0x2040
cmpq $0x0, -0x48(%rbp)
je 0x11d3c
movq -0x48(%rbp), %rdi
callq 0x2120
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x98(%rbp), %eax
jge 0x11d6a
movq -0x80(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1bbd0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x11d43
movq -0x80(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/map.c
// Function: open_bseqs
static mm_bseq_file_t **open_bseqs(int n, const char **fn)
{
	mm_bseq_file_t **fp;
	int i, j;
	fp = (mm_bseq_file_t**)calloc(n, sizeof(mm_bseq_file_t*));
	for (i = 0; i < n; ++i) {
		if ((fp[i] = mm_bseq_open(fn[i])) == 0) {
			if (mm_verbose >= 1)
				fprintf(stderr, "ERROR: failed to open file '%s': %s\n", fn[i], strerror(errno));
			for (j = 0; j < i; ++j)
				mm_bseq_close(fp[j]);
			free(fp);
			return 0;
		}
	}
	return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x2220
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11e88
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1bb20
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x11e78
leaq 0x4c91e(%rip), %rax     # 0x5e710
cmpl $0x1, (%rax)
jl 0x11e3a
movq 0x4c1fa(%rip), %rax     # 0x5dff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2410
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x456a7(%rip), %rsi     # 0x574da
movb $0x0, %al
callq 0x2250
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x11e65
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1bbd0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x11e41
movq -0x20(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x11e90
jmp 0x11e7a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x11db8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/map.c
// Function: skip_seed
static inline int skip_seed(int flag, uint64_t r, const mm_seed_t *q, const char *qname, int qlen, const mm_idx_t *mi, int *is_self)
{
	*is_self = 0;
	if (qname && (flag & (MM_F_NO_DIAG|MM_F_NO_DUAL))) {
		const mm_idx_seq_t *s = &mi->seq[r>>32];
		int cmp;
		cmp = strcmp(qname, s->name);
		if ((flag&MM_F_NO_DIAG) && cmp == 0 && (int)s->len == qlen) {
			if ((uint32_t)r>>1 == (q->q_pos>>1)) return 1; // avoid the diagnonal anchors
			if ((r&1) == (q->q_pos&1)) *is_self = 1; // this flag is used to avoid spurious extension on self chain
		}
		if ((flag&MM_F_NO_DUAL) && cmp > 0) // all-vs-all mode: map once
			return 1;
	}
	if (flag & (MM_F_FOR_ONLY|MM_F_REV_ONLY)) {
		if ((r&1) == (q->q_pos&1)) { // forward strand
			if (flag & MM_F_REV_ONLY) return 1;
		} else {
			if (flag & MM_F_FOR_ONLY) return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq 0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x1323b
movslq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x1323b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x2230
movl %eax, -0x3c(%rbp)
movslq -0x8(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1321c
cmpl $0x0, -0x3c(%rbp)
jne 0x1321c
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x1321c
movq -0x10(%rbp), %rax
shrl %eax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
shrl %ecx
cmpl %ecx, %eax
jne 0x131f7
movl $0x1, -0x4(%rbp)
jmp 0x132a3
movq -0x10(%rbp), %rax
andq $0x1, %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x1321a
movq 0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x1321c
movslq -0x8(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x13239
cmpl $0x0, -0x3c(%rbp)
jle 0x13239
movl $0x1, -0x4(%rbp)
jmp 0x132a3
jmp 0x1323b
movslq -0x8(%rbp), %rax
andq $0x300000, %rax         # imm = 0x300000
cmpq $0x0, %rax
je 0x1329c
movq -0x10(%rbp), %rax
andq $0x1, %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x1327f
movslq -0x8(%rbp), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
je 0x1327d
movl $0x1, -0x4(%rbp)
jmp 0x132a3
jmp 0x1329a
movslq -0x8(%rbp), %rax
andq $0x100000, %rax         # imm = 0x100000
cmpq $0x0, %rax
je 0x13298
movl $0x1, -0x4(%rbp)
jmp 0x132a3
jmp 0x1329a
jmp 0x1329c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/./bseq.h
// Function: mm_qname_same
static inline int mm_qname_same(const char *s1, const char *s2)
{
	int l1, l2;
	l1 = mm_qname_len(s1);
	l2 = mm_qname_len(s2);
	return (l1 == l2 && strncmp(s1, s2, l1) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x141b0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x141b0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x19(%rbp)
jne 0x132ff
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2080
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/./bseq.h
// Function: mm_revcomp_bseq
static inline void mm_revcomp_bseq(mm_bseq1_t *s)
{
	int i, t, l = s->l_seq;
	for (i = 0; i < l>>1; ++i) {
		t = s->seq[l - i - 1];
		s->seq[l - i - 1] = seq_comp_table[(uint8_t)s->seq[i]];
		s->seq[i] = seq_comp_table[t];
	}
	if (l&1) s->seq[l>>1] = seq_comp_table[(uint8_t)s->seq[l>>1]];
	if (s->qual)
		for (i = 0; i < l>>1; ++i)
			t = s->qual[l - i - 1], s->qual[l - i - 1] = s->qual[i], s->qual[i] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x142cd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x4a498(%rip), %rax     # 0x5e720
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movslq -0x10(%rbp), %rcx
leaq 0x4a473(%rip), %rax     # 0x5e720
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14248
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1430b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x4a42b(%rip), %rax     # 0x5e720
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1438b
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x14389
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1431d
jmp 0x1438b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/format.c
// Function: mm_write_sam_hdr
int mm_write_sam_hdr(const mm_idx_t *idx, const char *rg, const char *ver, int argc, char *argv[])
{
	kstring_t str = {0,0,0};
	int ret = 0;
	mm_sprintf_lite(&str, "@HD\tVN:1.6\tSO:unsorted\tGO:query\n");
	if (idx) {
		uint32_t i;
		for (i = 0; i < idx->n_seq; ++i)
			mm_sprintf_lite(&str, "@SQ\tSN:%s\tLN:%d\n", idx->seq[i].name, idx->seq[i].len);
	}
	if (rg) ret = sam_write_rg_line(&str, rg);
	mm_sprintf_lite(&str, "@PG\tID:minimap2\tPN:minimap2");
	if (ver) mm_sprintf_lite(&str, "\tVN:%s", ver);
	if (argc > 1) {
		int i;
		mm_sprintf_lite(&str, "\tCL:minimap2");
		for (i = 1; i < argc; ++i)
			mm_sprintf_lite(&str, " %s", argv[i]);
	}
	mm_err_puts(str.s);
	free(str.s);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x21b0
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x431e5(%rip), %rsi     # 0x575b2
movb $0x0, %al
callq 0x144f0
cmpq $0x0, -0x8(%rbp)
je 0x14437
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x14435
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x48(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x48(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
leaq -0x40(%rbp), %rdi
leaq 0x430a6(%rip), %rsi     # 0x574c9
movb $0x0, %al
callq 0x144f0
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x143e2
jmp 0x14437
cmpq $0x0, -0x10(%rbp)
je 0x1444e
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x149d0
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x4317a(%rip), %rsi     # 0x575d3
movb $0x0, %al
callq 0x144f0
cmpq $0x0, -0x18(%rbp)
je 0x1447d
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq 0x43179(%rip), %rsi     # 0x575ef
movb $0x0, %al
callq 0x144f0
cmpl $0x1, -0x1c(%rbp)
jle 0x144cf
leaq -0x40(%rbp), %rdi
leaq 0x43168(%rip), %rsi     # 0x575f6
movb $0x0, %al
callq 0x144f0
movl $0x1, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x144cd
movq -0x28(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq -0x40(%rbp), %rdi
leaq 0x41f2f(%rip), %rsi     # 0x563ea
movb $0x0, %al
callq 0x144f0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1449c
jmp 0x144cf
movq -0x30(%rbp), %rdi
callq 0x5520
movq -0x30(%rbp), %rdi
callq 0x2040
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/format.c
// Function: mm_gen_cs_or_MD
int mm_gen_cs_or_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int is_MD, int no_iden, int is_qstrand)
{
	mm_bseq1_t t;
	kstring_t str;
	str.s = *buf, str.l = 0, str.m = *max_len;
	t.l_seq = strlen(seq);
	t.seq = (char*)seq;
	write_cs_ds_or_MD(km, &str, mi, &t, r, no_iden, is_MD, 0, 0, is_qstrand);
	*max_len = str.m;
	*buf = str.s;
	return str.l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x18(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2130
movl %eax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
movl 0x18(%rbp), %r9d
movl 0x10(%rbp), %r10d
movl 0x20(%rbp), %eax
leaq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rcx
xorl %r11d, %r11d
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x150f0
movq -0x68(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/format.c
// Function: get_sam_pri
static inline const mm_reg1_t *get_sam_pri(int n_regs, const mm_reg1_t *regs)
{
	int i;
	for (i = 0; i < n_regs; ++i)
		if (regs[i].sam_pri)
			return &regs[i];
	assert(n_regs == 0);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x16b5d
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x3c(%rax), %eax
shrl $0xc, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16b50
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x16b8c
jmp 0x16b52
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16b16
cmpl $0x0, -0xc(%rbp)
jne 0x16b65
jmp 0x16b84
leaq 0x40f1a(%rip), %rdi     # 0x57a86
leaq 0x40a99(%rip), %rsi     # 0x5760c
movl $0x1e0, %edx            # imm = 0x1E0
leaq 0x40f13(%rip), %rcx     # 0x57a92
callq 0x21a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/format.c
// Function: sam_write_sq
static void sam_write_sq(kstring_t *s, char *seq, int l, int rev, int comp)
{
	extern unsigned char seq_comp_table[256];
	if (rev) {
		int i;
		str_enlarge(s, l);
		for (i = 0; i < l; ++i) {
			int c = seq[l - 1 - i];
			s->s[s->l + i] = c < 128 && comp? seq_comp_table[c] : c;
		}
		s->l += l;
	} else str_copy(s, seq, seq + l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x16fc8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17180
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x16fb8
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x80, -0x24(%rbp)
jge 0x16f89
cmpl $0x0, -0x1c(%rbp)
je 0x16f89
movslq -0x24(%rbp), %rcx
leaq 0x477a0(%rip), %rax     # 0x5e720
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
jmp 0x16f8f
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x20(%rbp), %rsi
addq %rsi, %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x16f47
movslq -0x14(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x16fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rax
addq %rax, %rdx
callq 0x17110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/format.c
// Function: mm_write_sam
void mm_write_sam(kstring_t *s, const mm_idx_t *mi, const mm_bseq1_t *t, const mm_reg1_t *r, int n_regs, const mm_reg1_t *regs)
{
	int i;
	for (i = 0; i < n_regs; ++i)
		if (r == &regs[i]) break;
	mm_write_sam2(s, mi, t, 0, i, 1, &n_regs, &regs, NULL, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x170c6
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0x34(%rbp), %rdx
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x170b9
jmp 0x170c6
jmp 0x170bb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x17097
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x34(%rbp), %r8d
xorl %ecx, %ecx
movl $0x1, %r9d
leaq -0x24(%rbp), %r10
leaq -0x30(%rbp), %rax
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x16ff0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/format.c
// Function: str_enlarge
static inline void str_enlarge(kstring_t *s, int l)
{
	if (s->l + l + 1 > s->m) {
		s->m = s->l + l + 1;
		kroundup32(s->m);
		s->s = (char*)realloc(s->s, s->m);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x17280
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/format.c
// Function: mm_escape
static char *mm_escape(char *s)
{
	char *p, *q;
	for (p = q = s; *p; ++p) {
		if (*p == '\\') {
			++p;
			if (*p == 't') *q++ = '\t';
			else if (*p == '\\') *q++ = '\\';
		} else *q++ = *p;
	}
	*q = '\0';
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x17335
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x1730b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x172e9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x9, (%rax)
jmp 0x17309
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x17307
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x5c, (%rax)
jmp 0x17309
jmp 0x17322
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x17324
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x172a4
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/esterr.c
// Function: get_mini_idx
static int get_mini_idx(int qlen, const mm128_t *a, int32_t n, const uint64_t *mini_pos)
{
	int32_t x, L = 0, R = n - 1;
	x = get_for_qpos(qlen, a);
	while (L <= R) { // binary search
		int32_t m = ((uint64_t)L + R) >> 1;
		int32_t y = (int32_t)mini_pos[m];
		if (y < x) L = m + 1;
		else if (y > x) R = m - 1;
		else return m;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x19a20
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jg 0x19a0f
movslq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
shrq %rax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x199f0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x19a0d
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x19a03
movl -0x30(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x19a0b
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19a16
jmp 0x19a0d
jmp 0x199b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/esterr.c
// Function: get_for_qpos
static inline int32_t get_for_qpos(int32_t qlen, const mm128_t *a)
{
	int32_t x = (int32_t)a->y;
	int32_t q_span = a->y>>32 & 0xff;
	if (a->x>>63)
		x = qlen - 1 - (x + 1 - q_span); // revert the position to the forward strand of query
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xff, %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
je 0x19a70
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
subl -0x18(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/splitidx.c
// Function: mm_split_init
FILE *mm_split_init(const char *prefix, const mm_idx_t *mi)
{
	char *fn;
	FILE *fp;
	uint32_t i, k = mi->k;
	fn = (char*)calloc(strlen(prefix) + 10, 1);
	sprintf(fn, "%s.%.4d.tmp", prefix, mi->index);
	if ((fp = fopen(fn, "wb")) == NULL) {
		if (mm_verbose >= 1)
			fprintf(stderr, "[ERROR]\033[1;31m failed to write to temporary file '%s'\033[0m: %s\n", fn, strerror(errno));
		exit(1);
	}
	mm_err_fwrite(&k, 4, 1, fp);
	mm_err_fwrite(&mi->n_seq, 4, 1, fp);
	for (i = 0; i < mi->n_seq; ++i) {
		uint32_t l;
		l = strlen(mi->seq[i].name);
		mm_err_fwrite(&l, 1, 4, fp);
		mm_err_fwrite(mi->seq[i].name, 1, l, fp);
		mm_err_fwrite(&mi->seq[i].len, 4, 1, fp);
	}
	free(fn);
	return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2130
movq %rax, %rdi
addq $0xa, %rdi
movl $0x1, %esi
callq 0x2220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
leaq 0x3e11c(%rip), %rsi     # 0x57bea
movb $0x0, %al
callq 0x23c0
movq -0x18(%rbp), %rdi
leaq 0x3b609(%rip), %rsi     # 0x550e9
callq 0x2380
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x19b40
leaq 0x44c1a(%rip), %rax     # 0x5e710
cmpl $0x1, (%rax)
jl 0x19b36
movq 0x444f6(%rip), %rax     # 0x5dff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2410
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x3e0c7(%rip), %rsi     # 0x57bf6
movb $0x0, %al
callq 0x2250
movl $0x1, %edi
callq 0x23d0
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x5560
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x5560
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x19c1c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2130
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x5560
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x5560
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x24(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x5560
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19b79
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/splitidx.c
// Function: mm_split_rm_tmp
void mm_split_rm_tmp(const char *prefix, int n_splits)
{
	int i;
	char *fn;
	fn = CALLOC(char, strlen(prefix) + 10);
	for (i = 0; i < n_splits; ++i) {
		sprintf(fn, "%s.%.4d.tmp", prefix, i);
		remove(fn);
	}
	free(fn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2130
movq %rax, %rdi
addq $0xa, %rdi
movl $0x1, %esi
callq 0x2220
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x19fa9
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0x10(%rbp), %ecx
leaq 0x3dc5c(%rip), %rsi     # 0x57bea
movb $0x0, %al
callq 0x23c0
movq -0x18(%rbp), %rdi
callq 0x2070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x19f74
movq -0x18(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/bseq.c
// Function: mm_bseq_open
mm_bseq_file_t *mm_bseq_open(const char *fn)
{
	mm_bseq_file_t *fp;
	gzFile f;
	f = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(0, "r");
	if (f == 0) return 0;
	fp = (mm_bseq_file_t*)calloc(1, sizeof(mm_bseq_file_t));
	fp->fp = f;
	fp->ks = kseq_init(fp->fp);
	return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bb5e
movq -0x10(%rbp), %rdi
leaq 0x3b854(%rip), %rsi     # 0x57392
callq 0x2230
cmpl $0x0, %eax
je 0x1bb5e
movq -0x10(%rbp), %rdi
leaq 0x3ad64(%rip), %rsi     # 0x568b7
callq 0x2340
movq %rax, -0x28(%rbp)
jmp 0x1bb70
xorl %edi, %edi
leaq 0x3ad50(%rip), %rsi     # 0x568b7
callq 0x20f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1bb89
movq $0x0, -0x8(%rbp)
jmp 0x1bbc6
movl $0x1, %edi
movl $0x38, %esi
callq 0x2220
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1b570
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/sketch.c
// Function: tq_shift
static inline int tq_shift(tiny_queue_t *q)
{
	int x;
	if (q->count == 0) return -1;
	x = q->a[q->front++];
	q->front &= 0x1f;
	--q->count;
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1d43b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d474
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0x1f, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%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/sdust.c
// Function: sdust_buf_init
sdust_buf_t *sdust_buf_init(void *km)
{
	sdust_buf_t *buf;
	buf = (sdust_buf_t*)kcalloc(km, 1, sizeof(sdust_buf_t));
	buf->km = km;
	buf->w = kdq_init(int, buf->km);
	kdq_resize(int, buf->w, 8);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x40, %edx
callq 0x1a790
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1d5c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x8, %esi
callq 0x1d670
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/sdust.c
// Function: sdust
uint64_t *sdust(void *km, const uint8_t *seq, int l_seq, int T, int W, int *n)
{
	uint64_t *ret;
	sdust_buf_t *buf;
	buf = sdust_buf_init(km);
	ret = (uint64_t*)sdust_core(seq, l_seq, T, W, n, buf);
	buf->res.a = 0;
	sdust_buf_destroy(buf);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d550
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x1da10
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x38(%rbp), %rdi
callq 0x1d950
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/lchain.c
// Function: comput_sc_simple
static inline int32_t comput_sc_simple(const mm128_t *ai, const mm128_t *aj, float chn_pen_gap, float chn_pen_skip, int32_t *exact, int32_t *width)
{
	int32_t dq = (int32_t)ai->y - (int32_t)aj->y, dr, dd, dg, q_span, sc;
	dr = (int32_t)(ai->x - aj->x);
	*width = dd = dr > dq? dr - dq : dq - dr;
	dg = dr < dq? dr : dq;
	q_span = aj->y>>32&0xff;
	sc = q_span < dg? q_span : dg;
	if (exact) *exact = (dd == 0 && dg <= q_span);
	if (dd || dq > q_span) {
		float lin_pen, log_pen;
		lin_pen = chn_pen_gap * (float)dd + chn_pen_skip * (float)dg;
		log_pen = dd >= 1? mg_log2(dd + 1) : 0.0f; // mg_log2() only works for dd>=2
		sc -= (int)(lin_pen + .5f * log_pen);
	}
	return sc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x223ab
movl -0x30(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x223b4
movl -0x2c(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x223d0
movl -0x30(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x223d6
movl -0x2c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xff, %rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x22401
movl -0x3c(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x22407
movl -0x38(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x22439
xorl %eax, %eax
cmpl $0x0, -0x34(%rbp)
movb %al, -0x55(%rbp)
jne 0x2242b
movl -0x38(%rbp), %eax
cmpl -0x3c(%rbp), %eax
setle %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x34(%rbp)
jne 0x22447
movl -0x2c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jle 0x224c2
movss -0x14(%rbp), %xmm0
cvtsi2ssl -0x34(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
cvtsi2ssl -0x38(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
cmpl $0x1, -0x34(%rbp)
jl 0x22488
movl -0x34(%rbp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
callq 0x224d0
movss %xmm0, -0x5c(%rbp)
jmp 0x22492
xorps %xmm0, %xmm0
movss %xmm0, -0x5c(%rbp)
jmp 0x22492
movss -0x5c(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x44(%rbp), %xmm1
movss -0x48(%rbp), %xmm0
movss 0x3436e(%rip), %xmm2    # 0x5681c
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl -0x40(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: mm_count_gaps
static inline void mm_count_gaps(const mm_reg1_t *r, int32_t *n_gap_, int32_t *n_gapo_)
{
	uint32_t i;
	int32_t n_gapo = 0, n_gap = 0;
	*n_gap_ = *n_gapo_ = -1;
	if (r->p == 0) return;
	for (i = 0; i < r->p->n_cigar; ++i) {
		int32_t op = r->p->cigar[i] & 0xf, len = r->p->cigar[i] >> 4;
		if (op == MM_CIGAR_INS || op == MM_CIGAR_DEL)
			++n_gapo, n_gap += len;
	}
	*n_gap_ = n_gap, *n_gapo_ = n_gapo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x227df
jmp 0x2285d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jae 0x2284b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x1c(%rbp), %ecx
movl 0x1c(%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x1c(%rbp), %ecx
movl 0x1c(%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x28(%rbp)
je 0x2282c
cmpl $0x2, -0x28(%rbp)
jne 0x2283e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x22840
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x227e6
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: mm_recal_max_dp
static int32_t mm_recal_max_dp(const mm_reg1_t *r, double b2, int32_t match_sc)
{
	uint32_t i;
	int32_t n_gap = 0, n_mis;
	double gap_cost = 0.0;
	if (r->p == 0) return -1;
	for (i = 0; i < r->p->n_cigar; ++i) {
		int32_t op = r->p->cigar[i] & 0xf, len = r->p->cigar[i] >> 4;
		if (op == MM_CIGAR_INS || op == MM_CIGAR_DEL) {
			gap_cost += b2 + (double)mg_log2(1.0 + len);
			n_gap += len;
		}
	}
	n_mis = r->blen + r->p->n_ambi - r->mlen - n_gap;
	return (int32_t)(match_sc * (r->mlen - b2 * n_mis - gap_cost) + .499);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x22aea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22c0c
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jae 0x22b92
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x20(%rbp), %ecx
movl 0x1c(%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x20(%rbp), %ecx
movl 0x1c(%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x38(%rbp)
cmpl $0x1, -0x34(%rbp)
je 0x22b3b
cmpl $0x2, -0x34(%rbp)
jne 0x22b82
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x38(%rbp), %xmm1
movsd 0x324be(%rip), %xmm0    # 0x55010
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x26080
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x22b84
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x22af1
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
movl 0x14(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
addl %ecx, %eax
movq -0x10(%rbp), %rcx
subl 0x2c(%rcx), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
cvtsi2sdl 0x2c(%rax), %xmm2
movsd -0x18(%rbp), %xmm1
cvtsi2sdl -0x28(%rbp), %xmm3
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
subsd -0x30(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x32417(%rip), %xmm1    # 0x55018
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: mm_insert_reg
static inline mm_reg1_t *mm_insert_reg(const mm_reg1_t *r, int i, int *n_regs, mm_reg1_t *regs)
{
	regs = (mm_reg1_t*)realloc(regs, (*n_regs + 1) * sizeof(mm_reg1_t));
	if (i + 1 != *n_regs)
		memmove(&regs[i + 2], &regs[i + 1], sizeof(mm_reg1_t) * (*n_regs - i - 1));
	regs[i + 1] = *r;
	++*n_regs;
	return regs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
imulq $0x50, %rax, %rsi
callq 0x2310
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x25a7e
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x2, %eax
cltq
imulq $0x50, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0x50, %rax, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x50, %rax, %rdx
callq 0x2330
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0x50, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x2290
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)