LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/primatesv1gibbon80/ref/primate.cpp
// Function: GenerateRoundConstants()
void GenerateRoundConstants() //Generation of 5-bit round constant by using the primitive polynomial x^5+x^2+1 with initial value 1.
{
	//Round constants for p_1
	rc_p1[0]=1;
	//printf("\nRound constants for p_1: \n %.2x", rc_p1[0]);
	for(int i=1; i<p1rounds; i++){
		rc_p1[i] = ((rc_p1[i-1]<<1) ^ ((rc_p1[i-1]>>1)&1) ^ ((rc_p1[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p1[i]);
	}

	//Round constant for p_2
	rc_p2[0] = ((rc_p1[p1rounds-1]<<1) ^ ((rc_p1[p1rounds-1]>>1)&1) ^ ((rc_p1[p1rounds-1]>>4)&1))&31;
	//printf("\nRound constants for p_2: \n %.2x", rc_p2[0]);
	for(int i=1; i<p2rounds; i++){
		rc_p2[i] = ((rc_p2[i-1]<<1) ^ ((rc_p2[i-1]>>1)&1) ^ ((rc_p2[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p2[i]);
	}
	
	//Round constant for p_3
	rc_p3[0] = ((rc_p2[p2rounds-1]<<1) ^ ((rc_p2[p2rounds-1]>>1)&1) ^ ((rc_p2[p2rounds-1]>>4)&1))&31;
	//printf("\nRound constants for p_3: \n %.2x", rc_p3[0]);
	for(int i=1; i<p3rounds; i++){
		rc_p3[i] = ((rc_p3[i-1]<<1) ^ ((rc_p3[i-1]>>1)&1) ^ ((rc_p3[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p3[i]);
	}
}

// Assembly:
movq 0x2e2d(%rip), %rax      # 0x5fc0
movb $0x1, (%rax)
movl $0x1, %ecx
movb $0x1, %dl
leal (%rdx,%rdx), %esi
movl %edx, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %dl
andb $0x1, %dl
andb $0x1e, %sil
orb %dil, %sil
xorb %dl, %sil
movb %sil, (%rax,%rcx)
incq %rcx
movl %esi, %edx
cmpq $0xc, %rcx
jne 0x319d
movb 0xb(%rax), %cl
leal (%rcx,%rcx), %eax
movl %ecx, %edx
shrb %dl
andb $0x1, %dl
shrb $0x4, %cl
andb $0x1, %cl
andb $0x1e, %al
orb %dl, %al
xorb %cl, %al
movq 0x2df8(%rip), %rcx      # 0x5fe0
movb %al, (%rcx)
movl $0x1, %edx
leal (%rax,%rax), %esi
movl %eax, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %al
andb $0x1, %al
andb $0x1e, %sil
orb %dil, %sil
xorb %al, %sil
movb %sil, (%rcx,%rdx)
incq %rdx
movl %esi, %eax
cmpq $0x6, %rdx
jne 0x31ef
movb 0x5(%rcx), %cl
leal (%rcx,%rcx), %eax
movl %ecx, %edx
shrb %dl
andb $0x1, %dl
shrb $0x4, %cl
andb $0x1, %cl
andb $0x1e, %al
orb %dl, %al
xorb %cl, %al
movq 0x2dbf(%rip), %rcx      # 0x5ff8
movb %al, (%rcx)
movl $0x1, %edx
leal (%rax,%rax), %esi
movl %eax, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %al
andb $0x1, %al
andb $0x1e, %sil
orb %dil, %sil
xorb %al, %sil
movb %sil, (%rcx,%rdx)
incq %rdx
movl %esi, %eax
cmpq $0x6, %rdx
jne 0x3240
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/samples/testkey/testkey.cpp
// Function: TestKey::TestKey()
TestKey::TestKey()
{
	Point	 pos;

	pos.x = 85;
	pos.y = 28;

	wnd	= new GUI::Window("TestKey - by Robert Kausch 2000-2020", Point(80, 80), Size(300, 160));
	title	= new Titlebar(TB_MINBUTTON | TB_CLOSEBUTTON);
	text	= new Text("ASCII code: 000\nUnicode character: 00000\n\nScan code: 000\nVirtual keycode: 000", pos);

	Add(wnd);

	wnd->Add(title);
	wnd->Add(text);

	wnd->onEvent.Connect(&TestKey::EventProc, this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movq %rsp, %rdi
callq 0x3180
leaq 0x3581(%rip), %rax      # 0x6af8
movq %rax, (%rbx)
movabsq $0x1c00000000, %rax     # imm = 0x1C00000000
movq %rax, 0x18(%rsp)
movl $0x55, 0x18(%rsp)
movl $0x6d8, %edi            # imm = 0x6D8
callq 0x31c0
movq %rax, %r15
leaq 0x1a79(%rip), %rsi      # 0x501e
movq %rsp, %rdi
callq 0x3290
movabsq $0x5000000050, %rax     # imm = 0x5000000050
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movabsq $0xa00000012c, %rax     # imm = 0xA00000012C
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %rsp, %rsi
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x3110
movq %r15, 0x5b8(%rbx)
movq %rsp, %rdi
callq 0x3180
movl $0x5c8, %edi            # imm = 0x5C8
callq 0x31c0
movq %rax, %r15
movq %rax, %rdi
movl $0x5, %esi
callq 0x30c0
movq %r15, 0x5c0(%rbx)
movl $0x5c0, %edi            # imm = 0x5C0
callq 0x31c0
movq %rax, %r15
leaq 0x1a20(%rip), %rsi      # 0x5043
movq %rsp, %rdi
callq 0x3290
leaq 0x20(%rsp), %rcx
movq $0x0, (%rcx)
movq %rsp, %rsi
leaq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x3080
movq %r15, 0x5c8(%rbx)
movq %rsp, %rdi
callq 0x3180
movq 0x5b8(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq 0x5b8(%rbx), %rdi
movq 0x5c0(%rbx), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x5b8(%rbx), %rdi
movq 0x5c8(%rbx), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movl $0x668, %edi            # imm = 0x668
addq 0x5b8(%rbx), %rdi
leaq 0x75(%rip), %rsi        # 0x3716
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3a86
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x36c5
movq %rax, %r14
movl $0x5c0, %esi            # imm = 0x5C0
jmp 0x36eb
movq %rax, %r14
movl $0x5c8, %esi            # imm = 0x5C8
jmp 0x36eb
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x36e6
movq %rax, %r14
movl $0x6d8, %esi            # imm = 0x6D8
movq %r15, %rdi
callq 0x3040
jmp 0x3705
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x370d
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3100
nop
// File: /workspace/github_c_makefile_star2_O1/openshmem-org[P]openshmem-examples/c/dip.c
// Function: main
int
main(void)
{
    double *f;
    int me;

    shmem_init();
    me = shmem_my_pe();

    f = (double *) shmem_malloc(sizeof(*f));

    *f = PI;
    shmem_barrier_all();

    if (me == 0) {
        shmem_double_p(f, E, 1);
    }

    shmem_barrier_all();


    if (me == 1) {
        printf("PE %d: %f, %s\n",
               me, *f, (fabs(*f - E) < epsilon) ? "OK" : "FAIL");
    }

    shmem_free(f);

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x1080
callq 0x1050
movl %eax, %ebp
movl $0x8, %edi
callq 0x1060
movq %rax, %rbx
movabsq $0x400921fb53c8d4f1, %rax # imm = 0x400921FB53C8D4F1
movq %rax, (%rbx)
callq 0x1070
testl %ebp, %ebp
jne 0x11f3
movsd 0xe22(%rip), %xmm0      # 0x2008
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10a0
callq 0x1070
cmpl $0x1, %ebp
jne 0x1246
movsd (%rbx), %xmm0
movsd 0xe07(%rip), %xmm1      # 0x2010
addsd %xmm0, %xmm1
andpd 0xe0b(%rip), %xmm1      # 0x2020
movsd 0xdfb(%rip), %xmm2      # 0x2018
ucomisd %xmm1, %xmm2
leaq 0xe17(%rip), %rax       # 0x203f
leaq 0xe13(%rip), %rdx       # 0x2042
cmovaq %rax, %rdx
leaq 0xdf6(%rip), %rdi       # 0x2030
movl $0x1, %esi
movb $0x1, %al
callq 0x1030
movq %rbx, %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: mp_idx_print_stat
void mp_idx_print_stat(const mp_idx_t *mi, int32_t max_occ)
{
	int64_t tot = 0, sum_large = 0;
	uint32_t i, n, n_occupied = 0, n_large = 0;
	n = mp_n_bucket(&mi->opt);
	for (i = 0; i < n - 1; ++i) {
		int64_t c = mi->ki[i+1] - mi->ki[i];
		if (c > 0) ++n_occupied;
		if (c > max_occ) ++n_large, sum_large += c;
		else tot += c;
	}
	fprintf(stderr, "[M::%s] %d distinct k-mers; mean occ of infrequent k-mers: %.2f; %d frequent k-mers accounting for %ld occurrences\n", __func__,
			n_occupied, (double)tot / (n_occupied - n_large), n_large, (long)sum_large);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rdi), %ecx
shll $0x2, %ecx
subl 0xc(%rdi), %ecx
jne 0x28eb
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x2962
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
shll %cl, %r8d
movq 0x28(%rdi), %rax
cmpl $-0x2, %r8d
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
cmovbl %r8d, %edx
movslq %esi, %rsi
notl %edx
xorl %edi, %edi
xorl %r11d, %r11d
xorl %r10d, %r10d
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %r9d, %r9d
movq 0x8(%rax,%r11,8), %rbx
subq (%rax,%r11,8), %rbx
leaq 0x1(%r11), %r14
xorl %r11d, %r11d
testq %rbx, %rbx
setg %r11b
addl %r11d, %ecx
xorl %r11d, %r11d
cmpq %rsi, %rbx
movl $0x0, %r15d
cmovgq %rbx, %r15
setg %r11b
cmovgq %rdi, %rbx
addq %r15, %r9
addl %r11d, %r8d
addq %rbx, %r10
movq %r14, %r11
cmpq %r14, %rdx
jne 0x291a
cvtsi2sd %r10, %xmm0
movq 0x15687(%rip), %rax     # 0x17ff0
movl %ecx, %edx
subl %r8d, %edx
cvtsi2sd %rdx, %xmm1
movq (%rax), %rdi
divsd %xmm1, %xmm0
leaq 0x10c6f(%rip), %rsi     # 0x135f0
leaq 0x10cdc(%rip), %rdx     # 0x13664
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/nasw-tab.c
// Function: ns_opt_init
void ns_opt_init(ns_opt_t *opt)
{
	memset(opt, 0, sizeof(*opt));
	opt->go = 11, opt->ge = 1;
	opt->io = 29;
	opt->fs = 17;
	opt->xdrop = 100;
	opt->end_bonus = 5;
	ns_opt_set_sp(opt, NS_S_MAMMAL);
	opt->sp_null_bonus = -7;
	opt->asize = 22;
	opt->ie_coef = .5f;
	opt->sc = ns_mat_blosum62;
	opt->nt4 = ns_tab_nt4;
	opt->aa20 = ns_tab_aa20;
	opt->codon = ns_tab_codon;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movabsq $0x10000000b, %rax      # imm = 0x10000000B
movq %rax, 0x4(%rdi)
movl $0x1d, 0xc(%rdi)
movaps 0xe9fa(%rip), %xmm0     # 0x12cc0
movups %xmm0, 0x10(%rdi)
movaps 0xe9df(%rip), %xmm0     # 0x12cb0
movups %xmm0, 0x20(%rdi)
movabsq $0x400000004, %rax      # imm = 0x400000004
movq %rax, 0x30(%rdi)
movabsq $0x3f000000fffffff9, %rax # imm = 0x3F000000FFFFFFF9
movq %rax, 0x38(%rdi)
leaq 0x13ef8(%rip), %rax     # 0x181f0
movq %rax, 0x40(%rdi)
leaq 0x140fd(%rip), %rax     # 0x18400
movq %rax, 0x48(%rdi)
leaq 0x141f2(%rip), %rax     # 0x18500
movq %rax, 0x50(%rdi)
leaq 0x143e7(%rip), %rax     # 0x18700
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/nasw-tab.c
// Function: ns_set_stop_sc
void ns_set_stop_sc(int32_t asize, int8_t *mat, int8_t pen)
{
	int32_t aa_stop = ns_tab_aa20['*'];
	int32_t i, score_ori = mat[aa_stop * asize + aa_stop];
	for (i = 0; i < asize; ++i)
		mat[aa_stop * asize + i] = mat[i * asize + aa_stop] = -pen;
	mat[aa_stop * asize + aa_stop] = score_ori;
}

// Assembly:
movzbl 0x14205(%rip), %eax     # 0x1852a
movslq %edi, %r10
movq %rax, %r9
imulq %r10, %r9
leaq (%r9,%rax), %rcx
movb (%rsi,%rcx), %r8b
testl %r10d, %r10d
jle 0x435d
negb %dl
movl %r9d, %r9d
movl %edi, %edi
addq %rsi, %rax
addq %rsi, %r9
xorl %r10d, %r10d
movb %dl, (%rax)
movb %dl, (%r9,%r10)
incq %r10
addq %rdi, %rax
cmpq %r10, %rdi
jne 0x434c
movb %r8b, (%rsi,%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/sys.c
// Function: mp_realtime
double mp_realtime(void)
{
	static double realtime0 = -1.0;
	struct timeval tp;
	double t;
	gettimeofday(&tp, NULL);
	t = tp.tv_sec + tp.tv_usec * 1e-6;
	if (realtime0 < 0.0) realtime0 = t;
	return t - realtime0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2140
cvtsi2sdq (%rbx), %xmm1
cvtsi2sdq 0x8(%rbx), %xmm0
mulsd 0xef6e(%rip), %xmm0     # 0x13360
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd 0x13fd6(%rip), %xmm1    # 0x183d8
jbe 0x440c
movsd %xmm0, 0x13fcc(%rip)    # 0x183d8
subsd 0x13fc4(%rip), %xmm0    # 0x183d8
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/options.c
// Function: mp_mapopt_set_max_intron
void mp_mapopt_set_max_intron(mp_mapopt_t *mo, int64_t gsize)
{
	int64_t x;
	x = (int64_t)(sqrt((double)gsize) * MP_MAX_INTRON_COEF + 1.);
	if (x < mo->min_max_intron) x = mo->min_max_intron;
	if (x > mo->max_max_intron) x = mo->max_max_intron;
	mo->bw = mo->max_intron = x;
	if (mp_verbose >= 3)
		fprintf(stderr, "[M::%s] set max intron size to %d\n", __func__, mo->max_intron);
}

// Assembly:
pushq %rbx
cvtsi2sd %rsi, %xmm0
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x49f9
sqrtsd %xmm0, %xmm0
jmp 0x49fe
callq 0x22f0
mulsd 0xea3a(%rip), %xmm0     # 0x13440
addsd 0xea3a(%rip), %xmm0     # 0x13448
cvttsd2si %xmm0, %rax
movslq 0x1c(%rbx), %rcx
cmpq %rcx, %rax
cmovgq %rax, %rcx
movslq 0x20(%rbx), %rax
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movl %ecx, 0x18(%rbx)
movl %ecx, 0x24(%rbx)
leaq 0x139aa(%rip), %rax     # 0x183e0
cmpl $0x3, (%rax)
jge 0x4a3d
popq %rbx
retq
movq 0x135ac(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
leaq 0xea5b(%rip), %rsi      # 0x134a9
leaq 0xea77(%rip), %rdx      # 0x134cc
xorl %eax, %eax
popq %rbx
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/options.c
// Function: mp_mapopt_init
void mp_mapopt_init(mp_mapopt_t *mo)
{
	memset(mo, 0, sizeof(*mo));
	mo->flag = 0;
	mo->mini_batch_size = 2000000;
	mo->max_occ = 20000;
	mo->max_gap = 1000;
	mo->max_intron = 200000;
	mo->min_max_intron = 10000, mo->max_max_intron = 300000;
	mo->bw = mo->max_intron;
	mo->min_chn_cnt = 3;
	mo->max_chn_max_skip = 25;
	mo->max_chn_iter = 1000000;
	mo->min_chn_sc = 0;
	mo->chn_coef_log = 0.75f;
	mo->max_ext = 10000;
	mo->max_ava = 1000;
	mo->mask_level = 0.5f;
	mo->mask_len = INT32_MAX;
	mo->pri_ratio = 0.7f;
	mo->best_n = 30;
	mo->out_n = 1000;
	mo->out_sim = 0.99f;
	mo->out_cov = 0.1f;
	#if MP_BITS_PER_AA == 4
	mo->kmer2 = 5;
	#else
	mo->kmer2 = 7;
	#endif

	mo->go = 11, mo->ge = 1;
	mo->io = 29;
	mo->fs = 23;
	mo->io_end = 19;
	mo->ie_coef = .5f;
	mo->sp_model = NS_S_GENERIC;
	mo->sp_null_bonus = -7;
	mo->sp_max_bonus = 14;
	mo->sp_scale = 1.0f;
	mo->end_bonus = 5;
	mo->xdrop = 100;
	mo->asize = 22;
	memcpy(mo->mat, ns_mat_blosum62, 484);
	ns_set_stop_sc(mo->asize, mo->mat, mo->fs);

	mo->gff_delim = -1;
	mo->gff_prefix = "MP";
	mo->max_intron_flank = 200;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x290, %edx            # imm = 0x290
xorl %esi, %esi
callq 0x2160
movq $0x1e8480, 0x8(%rbx)    # imm = 0x1E8480
movaps 0xe981(%rip), %xmm0     # 0x13400
movups %xmm0, 0x10(%rbx)
movabsq $0x30d40000493e0, %rax  # imm = 0x30D40000493E0
movq %rax, 0x20(%rbx)
movaps 0xe978(%rip), %xmm0     # 0x13410
movups %xmm0, 0x30(%rbx)
movl $0x3f400000, 0x40(%rbx) # imm = 0x3F400000
movabsq $0x3e800002710, %rax    # imm = 0x3E800002710
movq %rax, 0x28(%rbx)
movabsq $0x7fffffff3f000000, %rax # imm = 0x7FFFFFFF3F000000
movq %rax, 0x44(%rbx)
movl $0x3f333333, 0x4c(%rbx) # imm = 0x3F333333
movabsq $0x3e80000001e, %rax    # imm = 0x3E80000001E
movq %rax, 0x58(%rbx)
movabsq $0x3dcccccd3f7d70a4, %rax # imm = 0x3DCCCCCD3F7D70A4
movq %rax, 0x50(%rbx)
movaps 0xe937(%rip), %xmm0     # 0x13420
movups %xmm0, 0x60(%rbx)
movaps 0xe93c(%rip), %xmm0     # 0x13430
movups %xmm0, 0x70(%rbx)
movabsq $0xefffffff9, %rax      # imm = 0xEFFFFFFF9
movq %rax, 0x80(%rbx)
movabsq $0x643f800000, %rax     # imm = 0x643F800000
movq %rax, 0x88(%rbx)
movabsq $0x1600000005, %rax     # imm = 0x1600000005
movq %rax, 0x90(%rbx)
leaq 0xa8(%rbx), %r14
leaq 0x136b7(%rip), %rsi     # 0x181f0
movl $0x1e4, %edx            # imm = 0x1E4
movq %r14, %rdi
callq 0x21e0
movl $0x16, %edi
movq %r14, %rsi
movl $0x17, %edx
callq 0x431e
movabsq $0xc8ffffffff, %rax     # imm = 0xC8FFFFFFFF
movq %rax, 0x98(%rbx)
leaq 0xe975(%rip), %rax      # 0x134e5
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: mp_idx_boff
uint32_t *mp_idx_boff(const mp_ntdb_t *db, int32_t bbit, uint32_t *n_boff)
{
	int32_t i;
	int64_t boff = 0;
	uint32_t *bo;
	bo = Kmalloc(0, uint32_t, db->n_ctg * 2 + 1);
	for (i = 0; i < db->n_ctg; ++i) {
		bo[i<<1|0] = boff;
		boff += (db->ctg[i].len + (1<<bbit) - 1) >> bbit;
		bo[i<<1|1] = boff;
		boff += (db->ctg[i].len + (1<<bbit) - 1) >> bbit;
	}
	assert(boff < UINT32_MAX);
	bo[db->n_ctg*2] = *n_boff = boff;
	return bo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq (%rdi), %rax
leaq 0x4(,%rax,8), %rsi
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x80a1
cmpl $0x0, (%r14)
jle 0x4c29
movq 0x28(%r14), %rdx
movl $0x1, %esi
movl $0x1, %edi
movl %ebp, %ecx
shll %cl, %edi
movslq %edi, %rdi
decq %rdi
movl %ebp, %ecx
addq $0x8, %rdx
xorl %r8d, %r8d
movabsq $0x200000000, %r9       # imm = 0x200000000
xorl %r10d, %r10d
xorl %r15d, %r15d
movq %r8, %r11
sarq $0x1e, %r11
movl %r15d, (%rax,%r11)
movq (%rdx), %r11
addq %rdi, %r11
sarq %cl, %r11
addq %r11, %r15
movslq %esi, %rsi
movl %r15d, (%rax,%rsi,4)
addq %r11, %r15
incq %r10
movslq (%r14), %r11
addl $0x2, %esi
addq %r9, %r8
addq $0x18, %rdx
cmpq %r11, %r10
jl 0x4bf3
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r15
jge 0x4c48
movl %r15d, (%rbx)
movslq (%r14), %rcx
movl %r15d, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe8d1(%rip), %rdi      # 0x13520
leaq 0xe8dc(%rip), %rsi      # 0x13532
leaq 0xe8dd(%rip), %rcx      # 0x1353a
movl $0x17, %edx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: build_worker
static void build_worker(void *data, long j, int tid)
{
	worker_aux_t *aux = (worker_aux_t*)data;
	const mp_ntdb_t *nt = aux->mi->nt;
	const mp_idxopt_t *io = &aux->mi->opt;
	void *km = aux->km[tid], *km_tmp = aux->km_tmp[tid];
	int64_t len;
	uint8_t *seq;
	mp64_v a = {0,0,0};
	seq = Kmalloc(km_tmp, uint8_t, nt->ctg[j>>1].len);
	len = mp_ntseq_get(nt, j>>1, 0, -1, j&1, seq);
	mp_sketch_nt4(km_tmp, seq, len, io->min_aa_len, io->kmer, io->mod_bit, io->bbit, aux->mi->bo[j], &a);
	aux->a[j].m = aux->a[j].n = a.n;
	aux->a[j].a = Kmalloc(km, uint64_t, a.n);
	memcpy(aux->a[j].a, a.a, a.n * sizeof(uint64_t));
	kfree(km_tmp, a.a);
	kfree(km_tmp, seq);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %r12
movq 0x8(%rdi), %rax
movq 0x18(%r12), %rbp
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq (%rax,%rcx,8), %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movq 0x28(%rbp), %rax
movq %rsi, %r14
sarq %r14
leaq (%r14,%r14,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x80a1
movl %r13d, %r8d
andl $0x1, %r8d
movq %rbp, %rdi
movl %r14d, %esi
xorl %edx, %edx
movq $-0x1, %rcx
movq %rax, %r14
movq %rax, %r9
callq 0xc337
movl (%r12), %r10d
movl 0x4(%r12), %ecx
movl 0x8(%r12), %r8d
movl 0xc(%r12), %r9d
movq (%r15), %rdx
movq 0x30(%rdx), %rdx
movl (%rdx,%r13,4), %r11d
subq $0x8, %rsp
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %r12
movq %rax, %rdx
leaq 0x18(%rsp), %r14
pushq %r14
pushq %r11
pushq %r10
callq 0xd4fc
addq $0x20, %rsp
movl (%r14), %eax
movq 0x18(%r15), %rcx
shlq $0x4, %r13
movl %eax, (%rcx,%r13)
movl %eax, 0x4(%rcx,%r13)
movslq (%r14), %rsi
shlq $0x3, %rsi
movq 0x8(%rsp), %rdi
callq 0x80a1
movq 0x18(%r15), %rcx
movq %rax, 0x8(%rcx,%r13)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x21e0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x7fd6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7fd6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: mp_idx_destroy
void mp_idx_destroy(mp_idx_t *mi)
{
	if (mi == 0) return;
	mp_ntseq_destroy(mi->nt);
	free(mi->ki); free(mi->bo); free(mi->kb);
	free(mi);
}

// Assembly:
testq %rdi, %rdi
je 0x5113
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xc2c4
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x30(%rbx), %rdi
callq 0x2050
movq 0x38(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: mp_idx_dump
int mp_idx_dump(const char *fn, const mp_idx_t *mi)
{
	FILE *fp;
	fp = strcmp(fn, "-") == 0? stdout : fopen(fn, "wb");
	if (fp == 0) return -1;
	fwrite(MP_IDX_MAGIC, 1, 4, fp);
	fwrite(&mi->opt, sizeof(mi->opt), 1, fp);
	fwrite(&mi->n_kb, 8, 1, fp);
	mp_ntseq_dump(fp, mi->nt);
	fwrite(mi->ki, 8, mp_n_bucket(&mi->opt), fp);
	fwrite(mi->kb, 4, mi->n_kb, fp);
	if (fp != stdout) fclose(fp);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe5f0(%rip), %rsi      # 0x13715
callq 0x21b0
testl %eax, %eax
je 0x5142
leaq 0xe541(%rip), %rsi      # 0x13676
movq %r14, %rdi
callq 0x22a0
movq %rax, %r14
jmp 0x514c
movq 0x12e77(%rip), %rax     # 0x17fc0
movq (%rax), %r14
testq %r14, %r14
je 0x51f3
leaq 0xe51d(%rip), %rdi      # 0x13679
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x22e0
movl $0x14, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x22e0
leaq 0x20(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22e0
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xc6ef
movq 0x28(%rbx), %rdi
movl 0x8(%rbx), %ecx
shll $0x2, %ecx
subl 0xc(%rbx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl $0x8, %esi
movq %r14, %rcx
callq 0x22e0
movq 0x20(%rbx), %rdx
movq 0x38(%rbx), %rdi
movl $0x4, %esi
movq %r14, %rcx
callq 0x22e0
movq 0x12dde(%rip), %rax     # 0x17fc0
xorl %ebx, %ebx
cmpq (%rax), %r14
je 0x51f8
movq %r14, %rdi
callq 0x20f0
jmp 0x51f8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: mp_idx_restore
mp_idx_t *mp_idx_restore(const char *fn)
{
	FILE *fp;
	char magic[4];
	mp_idx_t *mi;

	fp = strcmp(fn, "-") == 0? stdin : fopen(fn, "rb");
	if (fp == 0) return 0;
	fread(magic, 1, 4, fp);
	if (strncmp(magic, MP_IDX_MAGIC, 4) != 0)
		return 0;
	mi = Kcalloc(0, mp_idx_t, 1);
	fread(&mi->opt, sizeof(mi->opt), 1, fp);
	ns_make_tables(mi->opt.trans_code);
	fread(&mi->n_kb, 8, 1, fp);
	mi->nt = mp_ntseq_restore(fp);
	mi->ki = Kmalloc(0, int64_t, mp_n_bucket(&mi->opt));
	mi->kb = Kmalloc(0, uint32_t, mi->n_kb);
	fread(mi->ki, 8, mp_n_bucket(&mi->opt), fp);
	fread(mi->kb, 4, mi->n_kb, fp);
	if (fp != stdin) fclose(fp);
	mi->bo = mp_idx_boff(mi->nt, mi->opt.bbit, &mi->n_block);
	if (mp_verbose >= 3)
		fprintf(stderr, "[M::%s@%.3f*%.2f] loaded the index\n", __func__, mp_realtime(), mp_percent_cpu());
	return mi;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe500(%rip), %rsi      # 0x13715
callq 0x21b0
testl %eax, %eax
je 0x5232
leaq 0xe459(%rip), %rsi      # 0x1367e
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
jmp 0x523c
movq 0x12d8f(%rip), %rax     # 0x17fc8
movq (%rax), %r14
testq %r14, %r14
je 0x5263
leaq 0xc(%rsp), %rbx
movl $0x1, %esi
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x20a0
cmpl $0x349504d, (%rbx)      # imm = 0x349504D
je 0x526a
xorl %ebx, %ebx
jmp 0x5360
movl $0x1, %esi
movl $0x40, %edx
xorl %edi, %edi
callq 0x7f34
movq %rax, %rbx
movl $0x14, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rcx
callq 0x20a0
movl 0x10(%rbx), %edi
callq 0x4084
leaq 0x20(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x20a0
movq %r14, %rdi
callq 0xc7b3
movq %rax, 0x18(%rbx)
movl 0x8(%rbx), %ecx
shll $0x2, %ecx
subl 0xc(%rbx), %ecx
movl $0x1, %r15d
movl $0x1, %esi
shll %cl, %esi
shlq $0x3, %rsi
xorl %edi, %edi
callq 0x80a1
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rsi
shlq $0x2, %rsi
xorl %edi, %edi
callq 0x80a1
movq %rax, 0x38(%rbx)
movq 0x28(%rbx), %rdi
movl 0x8(%rbx), %ecx
shll $0x2, %ecx
subl 0xc(%rbx), %ecx
shll %cl, %r15d
movl $0x8, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x20a0
movq 0x20(%rbx), %rdx
movq 0x38(%rbx), %rdi
movl $0x4, %esi
movq %r14, %rcx
callq 0x20a0
movq 0x12c97(%rip), %rax     # 0x17fc8
cmpq (%rax), %r14
je 0x533e
movq %r14, %rdi
callq 0x20f0
movq 0x18(%rbx), %rdi
movl (%rbx), %esi
movq %rbx, %rdx
addq $0x14, %rdx
callq 0x4b98
movq %rax, 0x30(%rbx)
leaq 0x13085(%rip), %rax     # 0x183e0
cmpl $0x3, (%rax)
jge 0x536d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x2a6e
jmp 0x5360
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: mp_idx_load
mp_idx_t *mp_idx_load(const char *fn, const mp_idxopt_t *io, int32_t n_threads)
{
	int64_t is_idx;
	is_idx = mp_idx_is_idx(fn);
	if (is_idx < 0) return 0;
	return is_idx? mp_idx_restore(fn) : mp_idx_build(fn, io, n_threads);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe387(%rip), %rsi      # 0x13715
callq 0x21b0
testl %eax, %eax
je 0x5404
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2290
testl %eax, %eax
js 0x5409
movl %eax, %ebp
xorl %r13d, %r13d
movl %eax, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2130
cmpq $0x4, %rax
jl 0x5433
movq %rax, %r12
xorl %r13d, %r13d
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2130
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
movl %ebp, %edi
callq 0x2190
cmpq $0x4, %rax
jne 0x5433
movzwl 0x4(%rsp), %eax
xorl $0x504d, %eax           # imm = 0x504D
movzbl 0x6(%rsp), %ecx
xorl $0x49, %ecx
orw %ax, %cx
je 0x5412
xorl %r13d, %r13d
jmp 0x5433
xorl %r13d, %r13d
jmp 0x543a
movq $-0x1, %r13
jmp 0x543a
movl 0x4(%rsp), %eax
bswapl %eax
xorl %ecx, %ecx
cmpl $0x4d504904, %eax       # imm = 0x4D504904
setae %cl
cmpl $0x4d504903, %eax       # imm = 0x4D504903
sbbl $0x0, %ecx
xorl %r13d, %r13d
testl %ecx, %ecx
cmovleq %r12, %r13
movl %ebp, %edi
callq 0x2170
testq %r13, %r13
js 0x5457
movq %r15, %rdi
je 0x5468
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5202
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4cc8
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/index.c
// Function: mp_set_spsc
void mp_set_spsc(const char *fn, mp_idx_t *mi, mp_mapopt_t *mo, int32_t keep_io)
{
	int32_t max_sc;
	if (fn == 0) return;
	if (!keep_io) mo->io += 10, mo->io_end += 10;
	max_sc = (mo->io + 1) / 2 - 1;
	if (max_sc > mo->io - mo->go) max_sc = mo->io - mo->go;
	if (max_sc > mo->sp_max_bonus) max_sc = mo->sp_max_bonus;
	mp_ntseq_read_spsc(mi->nt, fn, max_sc);
}

// Assembly:
testq %rdi, %rdi
je 0x54c6
movq %rdi, %rax
testl %ecx, %ecx
jne 0x5494
addl $0xa, 0x6c(%rdx)
addl $0xa, 0x74(%rdx)
movl 0x6c(%rdx), %ecx
leal 0x1(%rcx), %edi
shrl $0x1f, %edi
addl %ecx, %edi
incl %edi
sarl %edi
subl 0x64(%rdx), %ecx
decl %edi
cmpl %ecx, %edi
cmovll %edi, %ecx
movl 0x84(%rdx), %edx
cmpl %edx, %ecx
cmovgel %edx, %ecx
movq 0x18(%rsi), %rdi
movq %rax, %rsi
movl %ecx, %edx
jmp 0xcde4
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/map.c
// Function: mp_tbuf_init
mp_tbuf_t *mp_tbuf_init(void)
{
	mp_tbuf_t *b;
	b = Kcalloc(0, mp_tbuf_t, 1);
	if (!(mp_dbg_flag & MP_DBG_NO_KALLOC))
		b->km = km_init();
	return b;
}

// Assembly:
pushq %rbx
movl $0x1, %esi
movl $0x10, %edx
xorl %edi, %edi
callq 0x7f34
movq %rax, %rbx
leaq 0x1329c(%rip), %rax     # 0x18780
testb $0x1, (%rax)
jne 0x54f1
callq 0x7f77
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/map.c
// Function: mp_map_file
int32_t mp_map_file(const mp_idx_t *idx, const char *fn, const mp_mapopt_t *opt, int n_threads)
{
	pipeline_t pl;
	memset(&pl, 0, sizeof(pipeline_t));
	pl.fp = mp_bseq_open(fn);
	if (pl.fp == 0) return -1;
	pl.opt = opt, pl.mi = idx;
	pl.n_threads = n_threads > 1? n_threads : 1;
	if (opt->flag & MP_F_GFF) puts("##gff-version 3");
	kt_pipeline(2, worker_pipeline, &pl, 3);
	free(pl.str.s);
	mp_bseq_close(pl.fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0xd7f4
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x63e1
movq %rbx, 0x10(%rsp)
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
movq %r14, 0x20(%rsp)
movl %eax, (%rsp)
testb $0x8, (%rbx)
je 0x63af
leaq 0xd370(%rip), %rdi      # 0x1371a
callq 0x2090
leaq 0x39(%rip), %rsi        # 0x63ef
movq %rsp, %rbx
movl $0x2, %edi
movq %rbx, %rdx
movl $0x3, %ecx
callq 0x852c
movq 0x38(%rbx), %rdi
callq 0x2050
movq 0x18(%rbx), %rdi
callq 0xd868
xorl %eax, %eax
jmp 0x63e6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/map.c
// Function: worker_for
static void worker_for(void *_data, long i, int tid) // kt_for() callback
{
    step_t *s = (step_t*)_data;
	mp_bseq1_t *seq = &s->seq[i];
	if (mp_dbg_flag & MP_DBG_QNAME)
		fprintf(stderr, "QR\t%s\t%d\t%d\n", s->seq[i].name, s->seq[i].l_seq, tid);
	s->reg[i] = mp_map(s->p->mi, seq->l_seq, seq->seq, &s->n_reg[i], s->buf[tid], s->p->opt, seq->name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
shlq $0x5, %r15
leaq 0x11fb5(%rip), %rax     # 0x18780
addq 0x10(%rdi), %r15
testb $0x2, (%rax)
jne 0x6815
movq (%r14), %rax
movq 0x28(%r14), %r8
movq 0x10(%rax), %r9
movq 0x20(%rax), %rdi
movl (%r15), %esi
movq 0x10(%r15), %rdx
leaq (,%rbx,4), %rcx
addq 0x18(%r14), %rcx
movslq %ebp, %rax
movq (%r8,%rax,8), %r8
callq 0x5511
movq 0x20(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x117d4(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
movq 0x8(%r15), %rdx
movl (%r15), %ecx
leaq 0xcf4d(%rip), %rsi      # 0x1377a
movl %ebp, %r8d
xorl %eax, %eax
callq 0x21d0
jmp 0x67d4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/nasw-sse.c
// Function: ns_prep_nas
static void ns_prep_nas(const char *ns, int32_t nl, const ns_opt_t *opt, uint8_t *nas)
{
	int32_t i, l;
	uint8_t codon;
	memset(nas, opt->aa20['X'], nl);
	for (i = l = 0, codon = 0; i < nl; ++i) { // generate the real nas[]
		uint8_t c = opt->nt4[(uint8_t)ns[i]];
		if (c < 4) {
			codon = (codon << 2 | c) & 0x3f;
			if (++l >= 3)
				nas[i] = opt->codon[codon];
		} else codon = 0, l = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x50(%rdx), %rax
movslq %esi, %r12
movzbl 0x58(%rax), %esi
movq %rcx, %rdi
movq %r12, %rdx
callq 0x2160
testl %r12d, %r12d
jle 0xb938
movl %ebp, %eax
xorl %ecx, %ecx
xorl %edi, %edi
xorl %edx, %edx
movq 0x48(%r14), %rsi
movzbl (%r15,%rcx), %r8d
movzbl (%rsi,%r8), %r9d
movl $0x0, %r8d
movl $0x0, %esi
cmpq $0x3, %r9
ja 0xb92b
andl $0xf, %edi
leaq (%r9,%rdi,4), %rsi
leal 0x1(%rdx), %r8d
cmpl $0x2, %edx
jl 0xb92b
movq 0x58(%r14), %rdx
movb (%rdx,%rsi), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
movl %esi, %edi
movl %r8d, %edx
cmpq %rcx, %rax
jne 0xb8f2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_destroy
void mp_ntseq_destroy(mp_ntdb_t *db)
{
	mp_strmap_t *h = (mp_strmap_t*)db->h;
	if (db == 0) return;
	if (h) mp_strmap_destroy(h);
	if (db->spsc) free(db->spsc);
	free(db->ctg); free(db->seq); free(db->name);
	free(db);
}

// Assembly:
testq %rdi, %rdi
je 0xc336
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %r14
testq %r14, %r14
je 0xc300
movq (%r14), %r15
movq 0x18(%r14), %rsi
movq %r15, %rdi
callq 0x7fd6
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x7fd6
movq %r15, %rdi
movq %r14, %rsi
callq 0x7fd6
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xc30e
callq 0x2050
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x20(%rbx), %rdi
callq 0x2050
movq 0x30(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_get
int64_t mp_ntseq_get(const mp_ntdb_t *db, int32_t cid, int64_t st, int64_t en, int32_t rev, uint8_t *seq)
{
	int64_t i, s, e, k;
	if (cid >= db->n_ctg || cid < 0) return -1;
	if (en < 0 || en > db->ctg[cid].len) en = db->ctg[cid].len;
	s = db->ctg[cid].off + st;
	e = db->ctg[cid].off + en;
	if (!rev) {
		for (i = s, k = 0; i < e; ++i)
			seq[k++] = db->seq[i>>1] >> ((i&1) * 4) & 0xf;
	} else {
		for (i = e - 1, k = 0; i >= s; --i) {
			uint8_t c = db->seq[i>>1] >> ((i&1) * 4) & 0xf;
			seq[k++] = c >= 4? c : 3 - c;
		}
	}
	return k;
}

// Assembly:
movq $-0x1, %rax
testl %esi, %esi
js 0xc421
cmpl %esi, (%rdi)
jle 0xc421
movq %rcx, %r10
movl %esi, %eax
testq %rcx, %rcx
js 0xc367
movq 0x28(%rdi), %rcx
leaq (%rax,%rax,2), %rsi
cmpq %r10, 0x8(%rcx,%rsi,8)
jge 0xc374
movq 0x28(%rdi), %rcx
leaq (%rax,%rax,2), %rsi
movq 0x8(%rcx,%rsi,8), %r10
movq 0x28(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %rax
leaq (%rax,%rdx), %rsi
leaq (%rax,%r10), %r11
testl %r8d, %r8d
je 0xc3dd
cmpq %rdx, %r10
jle 0xc422
addl %eax, %r10d
shlb $0x2, %r10b
addb $-0x4, %r10b
xorl %eax, %eax
decq %r11
movq 0x20(%rdi), %rcx
movq %r11, %rdx
sarq %rdx
movb (%rcx,%rdx), %dl
movl %r10d, %ecx
andb $0x4, %cl
shrb %cl, %dl
andb $0xf, %dl
movb $0x3, %cl
subb %dl, %cl
movzbl %dl, %edx
movzbl %cl, %ecx
cmovbl %edx, %ecx
movb %cl, (%r9,%rax)
incq %rax
addb $-0x4, %r10b
cmpq %rsi, %r11
jg 0xc3a3
jmp 0xc421
cmpq %rdx, %r10
jle 0xc422
leal (,%rsi,4), %edx
xorl %r8d, %r8d
leaq (%rsi,%r8), %rax
movq 0x20(%rdi), %rcx
sarq %rax
movb (%rcx,%rax), %r10b
movl %edx, %ecx
andb $0x4, %cl
shrb %cl, %r10b
andb $0xf, %r10b
leaq 0x1(%r8), %rax
movb %r10b, (%r9,%r8)
leaq (%rsi,%r8), %rcx
incq %rcx
addb $0x4, %dl
movq %rax, %r8
cmpq %r11, %rcx
jl 0xc3ec
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_get_by_v
int64_t mp_ntseq_get_by_v(const mp_ntdb_t *nt, int32_t vid, int64_t st, int64_t en, uint8_t *seq)
{
	int64_t ctg_len = nt->ctg[vid>>1].len;
	if (st < 0 || en < 0 || st >= ctg_len) return -1;
	en = en <= ctg_len? en : ctg_len;
	return mp_ntseq_get(nt, vid>>1, vid&1? ctg_len - en : st, vid&1? ctg_len - st : en, vid&1, seq);
}

// Assembly:
pushq %rbx
movq %r8, %r9
movl %esi, %r8d
movq 0x28(%rdi), %rax
sarl %esi
movslq %esi, %r10
leaq (%r10,%r10,2), %r10
movq 0x8(%rax,%r10,8), %rax
movq %rcx, %r10
orq %rdx, %r10
setns %r11b
movq %rax, %r10
subq %rdx, %r10
setg %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0xc47b
cmpq %rcx, %rax
cmovlq %rax, %rcx
subq %rcx, %rax
andl $0x1, %r8d
cmoveq %rdx, %rax
cmoveq %rcx, %r10
movq %rax, %rdx
movq %r10, %rcx
popq %rbx
jmp 0xc337
movq $-0x1, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_spsc_get
int64_t mp_ntseq_spsc_get(const mp_ntdb_t *db, int32_t cid, int64_t st0, int64_t en0, int32_t rev, uint8_t *sc)
{
	int64_t st, en;
	const mp_spsc_t *s;
	if (cid >= db->n_ctg || cid < 0 || db->spsc == 0) return -1;
	if (en0 < 0 || en0 > db->ctg[cid].len) en0 = db->ctg[cid].len;
	if (!rev) st = st0, en = en0;
	else st = db->ctg[cid].len - en0, en = db->ctg[cid].len - st0;
	memset(sc, 0xff, en - st);
	s = &db->spsc[cid << 1 | (!!rev)];
	if (s->n > 0) {
		int32_t j, l, r;
		l = mp_ntseq_find_intv(s->n, s->a, st);
		r = mp_ntseq_find_intv(s->n, s->a, en);
		for (j = l + 1; j <= r; ++j) {
			int64_t x = (s->a[j]>>8) - st;
			uint8_t score = s->a[j] & 0xff;
			assert(x <= en - st);
			if (x == en - st) continue;
			if (sc[x] == 0xff || sc[x] < score) sc[x] = score;
		}
	}
	return en - st;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $-0x1, %r12
testl %esi, %esi
js 0xc5b8
movl %esi, %r13d
movq %rdi, %rbp
cmpl %esi, (%rdi)
jle 0xc5b8
cmpq $0x0, 0x40(%rbp)
je 0xc5b8
movq %rcx, %r15
movq %rdx, %r14
movl %r13d, %eax
testq %rcx, %rcx
js 0xc4d4
movq 0x28(%rbp), %rcx
leaq (%rax,%rax,2), %rdx
cmpq %r15, 0x8(%rcx,%rdx,8)
jge 0xc4e1
movq 0x28(%rbp), %rcx
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %r15
testl %r8d, %r8d
je 0xc502
movq 0x28(%rbp), %rcx
leaq (%rax,%rax,2), %rax
movq 0x8(%rcx,%rax,8), %rax
movq %rax, %rcx
subq %r15, %rcx
subq %r14, %rax
movq %rax, %r15
movq %rcx, %r14
xorl %ebx, %ebx
testl %r8d, %r8d
setne %bl
movq %r15, %r12
subq %r14, %r12
movq %r9, (%rsp)
movq %r9, %rdi
movl $0xff, %esi
movq %r12, %rdx
callq 0x2160
movq 0x40(%rbp), %rbp
leal (%rbx,%r13,2), %eax
cltq
shlq $0x4, %rax
movl (%rbp,%rax), %edi
testl %edi, %edi
je 0xc5b8
addq %rax, %rbp
movq 0x8(%rbp), %rsi
movq %r14, %rdx
callq 0xc5e9
movl %eax, %r13d
movl (%rbp), %edi
movq 0x8(%rbp), %rsi
movq %r15, %rdx
callq 0xc5e9
cmpl %eax, %r13d
jge 0xc5b8
movslq %r13d, %rcx
cltq
movl $0xff, %edx
movq (%rsp), %r11
movq 0x8(%rbp), %rsi
movq 0x8(%rsi,%rcx,8), %rsi
movq %rsi, %r8
shrq $0x8, %r8
movq %r8, %rdi
subq %r14, %rdi
cmpq %r12, %rdi
jg 0xc5ca
cmpq %r15, %r8
je 0xc5b0
movzbl (%r11,%rdi), %r8d
cmpl %edx, %r8d
setne %r9b
movl %esi, %r10d
andl %edx, %r10d
cmpl %r8d, %r10d
setbe %r8b
testb %r8b, %r9b
jne 0xc5b0
movb %sil, (%r11,%rdi)
incq %rcx
cmpq %rcx, %rax
jne 0xc56e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x77d1(%rip), %rdi      # 0x13da2
leaq 0x77d7(%rip), %rsi      # 0x13daf
leaq 0x77d8(%rip), %rcx      # 0x13db7
movl $0x93, %edx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_spsc_get_by_v
int64_t mp_ntseq_spsc_get_by_v(const mp_ntdb_t *nt, int32_t vid, int64_t st, int64_t en, uint8_t *ss)
{
	int64_t ctg_len = nt->ctg[vid>>1].len;
	if (st < 0 || en < 0 || st >= ctg_len) return -1;
	en = en <= ctg_len? en : ctg_len;
	return mp_ntseq_spsc_get(nt, vid>>1, vid&1? ctg_len - en : st, vid&1? ctg_len - st : en, vid&1, ss);
}

// Assembly:
pushq %rbx
movq %r8, %r9
movl %esi, %r8d
movq 0x28(%rdi), %rax
sarl %esi
movslq %esi, %r10
leaq (%r10,%r10,2), %r10
movq 0x8(%rax,%r10,8), %rax
movq %rcx, %r10
orq %rdx, %r10
setns %r11b
movq %rax, %r10
subq %rdx, %r10
setg %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0xc6e6
cmpq %rcx, %rax
cmovlq %rax, %rcx
subq %rcx, %rax
andl $0x1, %r8d
cmoveq %rdx, %rax
cmoveq %rcx, %r10
movq %rax, %rdx
movq %r10, %rcx
popq %rbx
jmp 0xc484
movq $-0x1, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_dump
void mp_ntseq_dump(FILE *fp, const mp_ntdb_t *nt)
{
	int32_t i, x[2];
	int64_t l = (nt->l_seq + 1) >> 1;
	x[0] = nt->n_ctg, x[1] = nt->l_name;
	fwrite(x, 4, 2, fp);
	fwrite(&nt->l_seq, 8, 1, fp);
	for (i = 0; i < nt->n_ctg; ++i)
		fwrite(&nt->ctg[i].len, 8, 1, fp);
	fwrite(nt->seq, 1, l, fp);
	fwrite(nt->name, 1, nt->l_name, fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsi), %r12
movq 0x10(%rsi), %r15
movl (%rsi), %eax
leaq 0x8(%rsp), %rdi
movl %eax, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x4(%rdi)
movl $0x4, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x22e0
movl $0x8, %r13d
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x22e0
cmpl $0x0, (%r14)
jle 0xc777
xorl %r12d, %r12d
movq 0x28(%r14), %rdi
addq %r13, %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22e0
incq %r12
movslq (%r14), %rax
addq $0x18, %r13
cmpq %rax, %r12
jl 0xc74f
incq %r15
sarq %r15
movq 0x20(%r14), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x22e0
movq 0x30(%r14), %rdi
movslq 0x8(%r14), %rdx
movl $0x1, %esi
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22e0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_restore
mp_ntdb_t *mp_ntseq_restore(FILE *fp)
{
	int32_t i, x[2];
	int64_t off = 0, l;
	mp_ntdb_t *nt;
	char *p;

	nt = Kcalloc(0, mp_ntdb_t, 1);
	fread(x, 4, 2, fp);
	fread(&nt->l_seq, 8, 1, fp);
	nt->n_ctg = nt->m_ctg = x[0];
	nt->l_name = x[1];
	nt->m_seq = nt->l_seq;
	l = (nt->l_seq + 1) >> 1;
	nt->ctg = Kcalloc(0, mp_ctg_t, nt->n_ctg);
	for (i = 0; i < nt->n_ctg; ++i) {
		fread(&nt->ctg[i].len, 8, 1, fp);
		nt->ctg[i].off = off;
		off += nt->ctg[i].len;
	}
	nt->seq = Kmalloc(0, uint8_t, l);
	nt->name = Kmalloc(0, char, nt->l_name);
	fread(nt->seq, 1, l, fp);
	fread(nt->name, 1, nt->l_name, fp);
	for (i = 0, p = nt->name; i < nt->n_ctg; ++i) {
		nt->ctg[i].name = p;
		p += strlen(p) + 1;
	}
	return nt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %esi
movl $0x48, %edx
xorl %edi, %edi
callq 0x7f34
movq %rax, %rbx
movq %rsp, %r15
movl $0x4, %esi
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x20a0
leaq 0x10(%rbx), %rdi
movl $0x8, %r12d
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x20a0
movslq (%r15), %rsi
movl %esi, 0x4(%rbx)
movl %esi, (%rbx)
movl 0x4(%r15), %eax
movl %eax, 0x8(%rbx)
movq 0x10(%rbx), %r15
movq %r15, 0x18(%rbx)
incq %r15
sarq %r15
movl $0x18, %edx
xorl %edi, %edi
callq 0x7f34
movq %rax, 0x28(%rbx)
cmpl $0x0, (%rbx)
jle 0xc875
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x28(%rbx), %rdi
addq %r12, %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x20a0
movq 0x28(%rbx), %rax
movq %rbp, -0x8(%rax,%r12)
addq (%rax,%r12), %rbp
incq %r13
movslq (%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0xc840
xorl %edi, %edi
movq %r15, %rsi
callq 0x80a1
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rsi
xorl %edi, %edi
callq 0x80a1
movq %rax, 0x30(%rbx)
movq 0x20(%rbx), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x20a0
movq 0x30(%rbx), %rdi
movslq 0x8(%rbx), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x20a0
movslq (%rbx), %rax
testq %rax, %rax
jle 0xc8f2
movq 0x28(%rbx), %r15
movq 0x30(%rbx), %r14
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movq %r14, 0x10(%r15,%r13)
movq %r14, %rdi
callq 0x2100
addq %rax, %r14
incq %r14
addq $0x18, %r13
cmpq %r13, %r12
jne 0xc8d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_name2id
int32_t mp_ntseq_name2id(const mp_ntdb_t *nt, const char *name)
{
	const mp_strmap_t *h = (const mp_strmap_t*)nt->h;
	khint_t k;
	if (h == 0) return -1;
	k = mp_strmap_get(h, name);
	return k == kh_end(h)? -1 : kh_val(h, k);
}

// Assembly:
movq 0x38(%rdi), %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r8, %r8
je 0xcde3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movb (%rsi), %cl
testb %cl, %cl
je 0xcd2f
leaq 0x1(%r14), %rdi
movl $0x811c9dce, %edx       # imm = 0x811C9DCE
movzbl %cl, %esi
xorl %edx, %esi
imull $0x1000193, %esi, %edx  # imm = 0x1000193
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xcd12
imull $0xca549e3b, %esi, %r15d # imm = 0xCA549E3B
jmp 0xcd35
movl $0xdf8667de, %r15d      # imm = 0xDF8667DE
movq 0x18(%r8), %r12
xorl %esi, %esi
movl $0x0, %edx
testq %r12, %r12
je 0xcdb6
movb 0x8(%r8), %cl
movl $0x1, %eax
shll %cl, %eax
negb %cl
shrl %cl, %r15d
movq %rax, 0x10(%rsp)
leal -0x1(%rax), %ebp
movq %r8, 0x8(%rsp)
movq 0x10(%r8), %r13
movl %r15d, %ebx
movl %ebx, %eax
shrl $0x5, %eax
movl (%r13,%rax,4), %eax
btl %ebx, %eax
jae 0xcd97
movl %ebx, %eax
leaq (%rax,%rax,2), %rax
movq (%r12,%rax,4), %rdi
movq %r14, %rsi
callq 0x21b0
testl %eax, %eax
je 0xcda8
incl %ebx
andl %ebp, %ebx
cmpl %r15d, %ebx
jne 0xcd69
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %rdx
jmp 0xcdb4
movl %ebx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x8(%rsp), %r8
xorl %esi, %esi
testq %r12, %r12
je 0xcdc6
movb 0x8(%r8), %cl
movl $0x1, %esi
shll %cl, %esi
cmpl %esi, %edx
je 0xcdd5
movl %edx, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%r12,%rax,4), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/sketch.c
// Function: mp_sketch_prot
void mp_sketch_prot(void *km, const char *seq, int32_t len, int32_t kmer, int32_t mod_bit, mp64_v *a)
{
	int32_t i, l = 0;
	uint32_t x = 0, y, mask_k = (1U<<kmer*MP_BITS_PER_AA) - 1, mask_mod = (1U<<mod_bit) - 1;
	a->n = 0;
	for (i = 0; i < len; ++i) {
		int32_t c = ns_tab_aa13[(uint8_t)seq[i]];
		if (c < 14) {
			#if MP_BITS_PER_AA == 4
			x = (x<<MP_BITS_PER_AA | c) & mask_k;
			#else
			x = (x<<MP_BITS_PER_AA | c>>1) & mask_k;
			#endif
			if (++l >= kmer) {
				y = mp_hash32_mask(x, mask_k);
				if ((y&mask_mod) == 0)
					kv_push(uint64_t, km, *a, (uint64_t)(y>>mod_bit)<<32 | i);
			}
		} else x = 0, l = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r10d
leal (,%r10,4), %ecx
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
shll %cl, %r12d
movl %r8d, %ecx
shll %cl, %r11d
movl $0x0, (%r9)
testl %edx, %edx
jle 0xd317
notl %r12d
notl %r11d
movl %edx, %ebp
xorl %r13d, %r13d
leaq 0xb401(%rip), %r15      # 0x18600
xorl %r14d, %r14d
xorl %eax, %eax
movq %r9, 0x20(%rsp)
movl %r8d, 0x4(%rsp)
movq %r10, 0x18(%rsp)
movl %r11d, (%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movzbl (%rsi,%r13), %ecx
movzbl (%r15,%rcx), %edx
movl $0x0, %ebx
movl $0x0, %ecx
cmpl $0xd, %edx
ja 0xd306
shll $0x4, %eax
orl %edx, %eax
movl %eax, %ebx
andl %r12d, %ebx
incl %r14d
cmpl %r10d, %r14d
jge 0xd258
movl %r14d, %ecx
jmp 0xd306
movl %ebx, %eax
shll $0xf, %eax
notl %eax
addl %ebx, %eax
andl %r12d, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
andl %r12d, %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
andl %r12d, %eax
movl %eax, %r15d
shrl $0x10, %r15d
xorl %eax, %r15d
testl %r11d, %r15d
jne 0xd2fc
movl 0x4(%r9), %eax
cmpl %eax, (%r9)
jne 0xd2de
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x2, %eax
cmovel %eax, %ecx
movl %ecx, 0x4(%r9)
movq 0x8(%r9), %rsi
movslq %ecx, %rdx
shlq $0x3, %rdx
movq 0x8(%rsp), %rdi
callq 0x81a4
movq 0x10(%rsp), %rsi
movl (%rsp), %r11d
movq 0x18(%rsp), %r10
movl 0x4(%rsp), %r8d
movq 0x20(%rsp), %r9
movq %rax, 0x8(%r9)
movl %r8d, %ecx
shrl %cl, %r15d
shlq $0x20, %r15
addq %r13, %r15
movq 0x8(%r9), %rax
movslq (%r9), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%r9)
movq %r15, (%rax,%rcx,8)
movl %r14d, %ecx
leaq 0xb2fa(%rip), %r15      # 0x18600
incq %r13
movl %ecx, %r14d
movl %ebx, %eax
cmpq %r13, %rbp
jne 0xd221
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/bseq.c
// Function: mp_bseq_open
mp_bseq_file_t *mp_bseq_open(const char *fn)
{
	mp_bseq_file_t *fp;
	gzFile f;
	f = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(0, "r");
	if (f == 0) return 0;
	fp = (mp_bseq_file_t*)calloc(1, sizeof(mp_bseq_file_t));
	fp->fp = f;
	fp->ks = kseq_init(fp->fp);
	return fp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd821
movq %rdi, %rbx
leaq 0x5f0e(%rip), %rsi      # 0x13715
callq 0x21b0
testl %eax, %eax
je 0xd821
leaq 0x4bc9(%rip), %rsi      # 0x123e0
movq %rbx, %rdi
callq 0x2260
jmp 0xd82f
leaq 0x4bb8(%rip), %rsi      # 0x123e0
xorl %edi, %edi
callq 0x20d0
movq %rax, %rbx
testq %rax, %rax
je 0xd85a
movl $0x1, %edi
movl $0x30, %esi
callq 0x21a0
movq %rax, %r14
movq %rbx, (%rax)
movq %rbx, %rdi
callq 0xbc55
movq %rax, 0x8(%r14)
jmp 0xd85d
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]miniprot/hit.c
// Function: mp_cal_chn_sc_ungap
int32_t mp_cal_chn_sc_ungap(int32_t n_a, const uint64_t *a, int32_t kmer)
{
	int32_t i, x = kmer;
	for (i = 1; i < n_a; ++i) {
		const uint64_t a0 = a[i - 1], a1 = a[i];
		int32_t dq = (int32_t)a1 - (int32_t)a0, dr3 = (a1>>32) - (a0>>32);
		int32_t dr = dr3 / 3, q = dr3 - dr * 3, dg;
		dg = dq < dr? dq : dr;
		if (dq >= dr && q != 0) --x;
		else x += dg < kmer? dg : kmer;
	}
	return x;
}

// Assembly:
cmpl $0x2, %edi
jl 0xe635
movl %edi, %ecx
movl $0x1, %edi
movl %edx, %eax
movq -0x8(%rsi,%rdi,8), %r10
movq (%rsi,%rdi,8), %r9
movl %r9d, %r8d
subl %r10d, %r8d
shrq $0x20, %r9
shrq $0x20, %r10
subl %r10d, %r9d
movslq %r9d, %r10
imulq $0x55555556, %r10, %r10 # imm = 0x55555556
movq %r10, %r11
shrq $0x3f, %r11
shrq $0x20, %r10
addl %r11d, %r10d
cmpl %r10d, %r8d
jl 0xe618
leal (%r10,%r10,2), %r11d
negl %r11d
negl %r9d
cmpl %r9d, %r11d
je 0xe618
decl %eax
jmp 0xe62c
cmpl %r10d, %r8d
cmovll %r8d, %r10d
cmpl %edx, %r10d
cmovgel %edx, %r10d
addl %eax, %r10d
movl %r10d, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0xe5ce
retq
movl %edx, %eax
retq