LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/leiradel[P]zx48k-libretro/src/main.c
// Function: zx48k_audio_cb
static void zx48k_audio_cb(float const* const samples, int const num_samples, void* const ud) {
    static int16_t pcm16[ZX_MAX_AUDIO_SAMPLES * 2];

    (void)ud;

    for (int i = 0, j = 0; i < num_samples; i++, j += 2) {
        float sample = samples[i];

        if (sample < -1.0f) {
            sample = -1.0f;
        }
        else if (sample > 1.0f) {
            sample = 1.0f;
        }

        pcm16[j] = sample * 32767;
        pcm16[j + 1] = sample * 32767;
    }

    zx48k.audio_cb(pcm16, num_samples);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x23c4f
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x24(%rbp)
movss 0x455(%rip), %xmm0      # 0x2400c
ucomiss -0x24(%rbp), %xmm0
jbe 0x23bcc
movss 0x447(%rip), %xmm0      # 0x2400c
movss %xmm0, -0x24(%rbp)
jmp 0x23bed
movss -0x24(%rbp), %xmm0
movss 0x437(%rip), %xmm1      # 0x24010
ucomiss %xmm1, %xmm0
jbe 0x23beb
movss 0x42a(%rip), %xmm0      # 0x24010
movss %xmm0, -0x24(%rbp)
jmp 0x23bed
movss -0x24(%rbp), %xmm0
movss 0x41a(%rip), %xmm1      # 0x24014
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movslq -0x20(%rbp), %rcx
leaq 0x89a80(%rip), %rax     # 0xad690
movw %dx, (%rax,%rcx,2)
movss -0x24(%rbp), %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x89a5c(%rip), %rax     # 0xad690
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
jmp 0x23b91
movq 0x89a22(%rip), %rax     # 0xad678
movslq -0xc(%rbp), %rsi
leaq 0x89a2f(%rip), %rdi     # 0xad690
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tools/gentab.c
// Function: main
int main(int argc, char **argv)
{
	uint32_t p;

	if (argc < 2) {
		fprintf(stderr, "usage: %s <polynomial>\n", argv[0]);
		return -1;
	}

	if (parse_poly(argv[1], &p) < 0)
		return -1;

	fill_table(p);
	print_table();
	return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x1196
movq 0x2e85(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0xe7f(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x11ce
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x4(%rsp), %rsi
callq 0x11e0
cmpl $0x0, %eax
jge 0x11b8
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x11ce
movl 0x4(%rsp), %edi
callq 0x1330
callq 0x13d0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tools/gentab.c
// Function: parse_poly
static int parse_poly(const char *text, uint32_t *out)
{
	uint32_t r = 0;

	while ((*text == '0') || (*text == 'x'))
		text++;

	while (*text) {
		char c = *(text++);

		r <<= 4;
		if ((c >= '0') && (c <= '9')) {
			r |= (c - '0');
		} else if ((c >= 'A') && (c <= 'F')) {
			r |= (c - 'A' + 10);
		} else if ((c >= 'a') && (c <= 'f')) {
			r |= (c - 'a' + 10);
		} else {
			fprintf(stderr, "parse_poly: invalid character: %s\n",
				text);
			return -1;
		}
	}

	*out = r;
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, 0xa(%rsp)
je 0x121b
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
sete %al
movb %al, 0xa(%rsp)
movb 0xa(%rsp), %al
testb $0x1, %al
jne 0x1225
jmp 0x1235
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x11f6
jmp 0x1237
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x130f
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %al
movb %al, 0xb(%rsp)
movl 0xc(%rsp), %eax
shll $0x4, %eax
movl %eax, 0xc(%rsp)
movsbl 0xb(%rsp), %eax
cmpl $0x30, %eax
jl 0x128d
movsbl 0xb(%rsp), %eax
cmpl $0x39, %eax
jg 0x128d
movsbl 0xb(%rsp), %eax
subl $0x30, %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x130a
movsbl 0xb(%rsp), %eax
cmpl $0x41, %eax
jl 0x12b6
movsbl 0xb(%rsp), %eax
cmpl $0x46, %eax
jg 0x12b6
movsbl 0xb(%rsp), %eax
subl $0x41, %eax
addl $0xa, %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x1308
movsbl 0xb(%rsp), %eax
cmpl $0x61, %eax
jl 0x12df
movsbl 0xb(%rsp), %eax
cmpl $0x66, %eax
jg 0x12df
movsbl 0xb(%rsp), %eax
subl $0x61, %eax
addl $0xa, %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x1306
movq 0x2d12(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0xd27(%rip), %rsi       # 0x201c
movb $0x0, %al
callq 0x1040
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1322
jmp 0x1308
jmp 0x130a
jmp 0x1237
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tools/gentab.c
// Function: fill_table
static void fill_table(uint32_t poly)
{
	int i;

	for (i = 0; i < 256; i++) {
		uint32_t r = i;
		int j;

		for (j = 0; j < 8; j++)
			r = (r >> 1) ^ ((r & 1) ? poly : 0);

		table[i] = r;
	}
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x100, -0x8(%rsp)      # imm = 0x100
jge 0x13c3
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x8, -0x10(%rsp)
jge 0x13a0
movl -0xc(%rsp), %eax
shrl %eax
movl %eax, -0x14(%rsp)
movl -0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x137d
movl -0x4(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x1385
xorl %eax, %eax
movl %eax, -0x18(%rsp)
jmp 0x1385
movl -0x14(%rsp), %eax
movl -0x18(%rsp), %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x1356
movl -0xc(%rsp), %edx
movslq -0x8(%rsp), %rcx
leaq 0x2ca0(%rip), %rax      # 0x4050
movl %edx, (%rax,%rcx,4)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x133c
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6444v2/ref/norx.c
// Function: norx_branch
static NORX_INLINE void norx_branch(norx_state_t state, uint64_t lane)
{
    norx_word_t * S = state->S;

    S[15] ^= BRANCH_TAG;
    norx_permute(state);

    /* Inject lane ID */
    #if NORX_W == 32
    S[13] ^= (lane >>  0) & 0xFFFFFFFF;
    S[14] ^= (lane >> 32) & 0xFFFFFFFF;
    #elif NORX_W == 64
    S[13] ^= lane;
    #endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x78(%rax), %rcx
xorq $0x10, %rcx
movq %rcx, 0x78(%rax)
movq 0x10(%rsp), %rdi
callq 0x2200
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
xorq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6444v2/ref/norx.c
// Function: norx_merge
static NORX_INLINE void norx_merge(norx_state_t state, norx_state_t state1)
{
    size_t i;
    norx_word_t * S = state->S;
    norx_word_t * S1 = state1->S;

    S1[15] ^= MERGE_TAG;
    norx_permute(state1);

    for (i = 0; i < 16; ++i) {
        S[i] ^= S1[i];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x78(%rax), %rcx
xorq $0x20, %rcx
movq %rcx, 0x78(%rax)
movq 0x18(%rsp), %rdi
callq 0x2200
movq $0x0, 0x10(%rsp)
cmpq $0x10, 0x10(%rsp)
jae 0x184b
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1814
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1080
callq 0x1050
movl %eax, 0x4(%rsp)
movl $0x8, %edi
callq 0x1060
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsd 0xe22(%rip), %xmm0      # 0x2008
movsd %xmm0, (%rax)
callq 0x1070
cmpl $0x0, 0x4(%rsp)
jne 0x120d
movq 0x8(%rsp), %rdi
movsd 0xe0d(%rip), %xmm0      # 0x2010
movl $0x1, %esi
callq 0x10a0
callq 0x1070
cmpl $0x1, 0x4(%rsp)
jne 0x1272
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
movsd (%rax), %xmm2
movsd 0xdd9(%rip), %xmm1      # 0x2010
subsd %xmm1, %xmm2
movaps 0xdde(%rip), %xmm1      # 0x2020
pand %xmm1, %xmm2
movsd 0xdca(%rip), %xmm1      # 0x2018
leaq 0xded(%rip), %rdx       # 0x2042
leaq 0xde3(%rip), %rax       # 0x203f
ucomisd %xmm2, %xmm1
cmovaq %rax, %rdx
leaq 0xdc5(%rip), %rdi       # 0x2030
movb $0x1, %al
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x2190
movq -0x8(%rbp), %rax
movl $0xb, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x1d, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x11, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x64, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x18(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x3ea0
movq -0x8(%rbp), %rax
movl $0xfffffff9, 0x38(%rax) # imm = 0xFFFFFFF9
movq -0x8(%rbp), %rax
movl $0x16, 0x1c(%rax)
movq -0x8(%rbp), %rax
movss 0x1cb4e(%rip), %xmm0    # 0x20b6c
movss %xmm0, 0x3c(%rax)
movq -0x8(%rbp), %rax
leaq 0x223a2(%rip), %rcx     # 0x263d0
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x226b3(%rip), %rcx     # 0x266f0
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
leaq 0x227a4(%rip), %rcx     # 0x267f0
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
leaq 0x22995(%rip), %rcx     # 0x269f0
movq %rcx, 0x58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl 0x22793(%rip), %eax     # 0x2681a
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x40ee
movsbl -0x11(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40a9
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2170
cvtsi2sdq -0x10(%rbp), %xmm1
cvtsi2sdq -0x8(%rbp), %xmm0
movsd 0x1d037(%rip), %xmm2    # 0x21200
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd 0x224ef(%rip), %xmm0    # 0x266d0
jbe 0x41f0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x224e0(%rip)    # 0x266d0
movsd -0x18(%rbp), %xmm0
subsd 0x224d3(%rip), %xmm0    # 0x266d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/misc.c
// Function: mp_strdup
char *mp_strdup(const char *src)
{
	size_t len;
	char *dst;
	len = strlen(src);
	dst = (char*)malloc(len + 1);
	memcpy(dst, src, len + 1);
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2110
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
callq 0x2200
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/options.c
// Function: mp_idxopt_init
void mp_idxopt_init(mp_idxopt_t *io)
{
	memset(io, 0, sizeof(*io));
	io->trans_code = MP_CODON_STD;
	io->bbit = 8;
	io->min_aa_len = 30;
	#if MP_BITS_PER_AA == 4
	io->kmer = 6;
	#else
	io->kmer = 8;
	#endif
	io->mod_bit = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x2190
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
movl $0x1e, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x6, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cvtsi2sdq -0x10(%rbp), %xmm0
callq 0x2320
movsd 0x1c4fd(%rip), %xmm1    # 0x21290
mulsd %xmm1, %xmm0
movsd 0x1c4f9(%rip), %xmm1    # 0x21298
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
cmpq %rcx, %rax
jge 0x4dc9
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x20(%rcx), %rcx
cmpq %rcx, %rax
jle 0x4de6
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
leaq 0x218d7(%rip), %rax     # 0x266d8
cmpl $0x3, (%rax)
jl 0x4e2c
movq 0x211eb(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0x1c4ef(%rip), %rsi     # 0x2130d
leaq 0x1c50b(%rip), %rdx     # 0x21330
movb $0x0, %al
callq 0x21f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/options.c
// Function: mp_mapopt_check
int32_t mp_mapopt_check(const mp_mapopt_t *mo)
{
	if (mo->sp_model < 0 || mo->sp_model > 2) {
		fprintf(stderr, "[ERROR]\033[1;31m option -j should be between 0 and 2\033[0m\n");
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jl 0x50c0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x7c(%rax)
jle 0x50e1
movq 0x20f31(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
leaq 0x1c27b(%rip), %rsi     # 0x2134c
movb $0x0, %al
callq 0x21f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50e8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xaeb0
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5204
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
orl $0x0, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
subq $0x1, %rax
movl -0xc(%rbp), %ecx
sarq %cl, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
orl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
subq $0x1, %rax
movl -0xc(%rbp), %ecx
sarq %cl, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5141
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x28(%rbp)
jge 0x5211
jmp 0x5230
leaq 0x1c16c(%rip), %rdi     # 0x21384
leaq 0x1c177(%rip), %rsi     # 0x21396
movl $0x17, %edx
leaq 0x1c173(%rip), %rcx     # 0x2139e
callq 0x2180
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movl %edx, (%rax)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shll %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/index.c
// Function: mp_idx_block2pos_core
static int32_t mp_idx_block2pos_core(const uint32_t *a, uint32_t n_a, uint32_t b)
{
	int32_t st = 0, en = n_a - 1;
	if (b >= a[n_a]) return -1;
	while (st <= en) {
		int32_t mid = (st + en) / 2;
		if (a[mid] <= b && b < a[mid+1]) return mid;
		else if (b < a[mid]) en = mid - 1;
		else st = mid + 1;
	}
	return -2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jb 0x52d6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x534d
jmp 0x52d8
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x5346
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
ja 0x531e
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x531e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x534d
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x5339
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5342
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5344
jmp 0x52d8
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2190
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
sarq %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0xaeb0
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
sarq %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
andq $0x1, %rax
movl %eax, %r8d
movq -0x50(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
movq $-0x1, %rcx
callq 0x16580
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x30(%rbp), %rax
movl 0xc(%rax), %r9d
movq -0x30(%rbp), %rax
movl (%rax), %r11d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %r10
movl (%rax,%r10,4), %eax
movl %eax, %r10d
leaq -0x60(%rbp), %rax
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x184b0
movl -0x60(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rdi
movslq -0x60(%rbp), %rsi
shlq $0x3, %rsi
callq 0xaeb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x58(%rbp), %rsi
movslq -0x60(%rbp), %rdx
shlq $0x3, %rdx
callq 0x2200
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xac90
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xac90
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5b60
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x5b14
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x24(%rbp), %edx
subq (%rcx,%rdx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jle 0x5ad4
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jle 0x5af8
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5b04
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x5b06
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a90
movq 0x204dd(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movl -0x2c(%rbp), %ecx
cvtsi2sdq -0x18(%rbp), %xmm0
movl -0x30(%rbp), %edx
movl %ecx, %eax
subl %edx, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movl -0x30(%rbp), %r8d
movq -0x20(%rbp), %r9
leaq 0x1b90e(%rip), %rsi     # 0x21454
leaq 0x1b97b(%rip), %rdx     # 0x214c8
movb $0x1, %al
callq 0x21f0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5ba5
jmp 0x5be2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x164e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1b96a(%rip), %rsi     # 0x21575
callq 0x21d0
cmpl $0x0, %eax
jne 0x5c25
movq 0x203b4(%rip), %rax     # 0x25fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5c39
movq -0x10(%rbp), %rdi
leaq 0x1b8aa(%rip), %rsi     # 0x214da
callq 0x22d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5c54
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d1a
movq -0x20(%rbp), %rcx
leaq 0x1b87e(%rip), %rdi     # 0x214dd
movl $0x1, %esi
movl $0x4, %edx
callq 0x2310
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x14, %esi
movl $0x1, %edx
callq 0x2310
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2310
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x16cf0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b60
movq -0x30(%rbp), %rdi
movl %eax, %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x8, %esi
callq 0x2310
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x4, %esi
callq 0x2310
movq -0x20(%rbp), %rax
movq 0x202cb(%rip), %rcx     # 0x25fd0
cmpq (%rcx), %rax
je 0x5d13
movq -0x20(%rbp), %rdi
callq 0x2100
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5fe0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x5fa1
movq $0x0, -0x8(%rbp)
jmp 0x5fd3
cmpq $0x0, -0x28(%rbp)
je 0x5fb7
movq -0x10(%rbp), %rdi
callq 0x5d30
movq %rax, -0x30(%rbp)
jmp 0x5fcb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5360
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6113
jmp 0x61a1
cmpl $0x0, -0x1c(%rbp)
jne 0x6133
movq -0x18(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0x6c(%rax)
movq -0x18(%rbp), %rax
movl 0x74(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0x74(%rax)
movq -0x18(%rbp), %rax
movl 0x6c(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x6c(%rcx), %ecx
movq -0x18(%rbp), %rdx
subl 0x64(%rdx), %ecx
cmpl %ecx, %eax
jle 0x6171
movq -0x18(%rbp), %rax
movl 0x6c(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x64(%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x84(%rcx), %eax
jle 0x618d
movq -0x18(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x171f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
movl $0x10, %edx
callq 0xab60
movq %rax, -0x8(%rbp)
leaq 0x2089a(%rip), %rax     # 0x26a70
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x61ef
callq 0xabf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/map.c
// Function: mp_cal_max_occ
static int32_t mp_cal_max_occ(void *km, const mp_idx_t *mi, int32_t n, const uint64_t *a)
{
	int32_t i, n_kmer;
	uint64_t *cnt, q25, q75;
	cnt = Kmalloc(km, uint64_t, n);
	n_kmer = mp_n_bucket(&mi->opt);
	for (i = 0; i < n; ++i) {
		int64_t en = (a[i]>>32) + 1 < n_kmer? mi->ki[(a[i]>>32) + 1] : mi->n_kb;
		cnt[i] = en - mi->ki[a[i]>>32];
	}
	radix_sort_mp64(cnt, cnt + n);
	q25 = cnt[(int64_t)(n * .25 + .499)];
	q75 = cnt[(int64_t)(n * .75 + .499)];
	kfree(km, cnt);
	return (int32_t)(q75 + (q75 - q25) * 1.5 + 10.); // threshold the outliers, the boxplot way (except for +10)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x3, %rsi
callq 0xaeb0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e20
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6f29
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
addq $0x1, %rax
movslq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jae 0x6edb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
jmp 0x6ee7
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
shrq $0x20, %rcx
subq (%rax,%rcx,8), %rdx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6e8f
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq (%rdi,%rax,8), %rsi
callq 0x46c0
movq -0x30(%rbp), %rax
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0x1a5dd(%rip), %xmm1    # 0x21528
mulsd %xmm1, %xmm0
movsd 0x190d1(%rip), %xmm1    # 0x20028
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0x1a5b7(%rip), %xmm2    # 0x21530
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xac90
movq -0x40(%rbp), %rax
movq %rax, %xmm1
movaps 0x1a595(%rip), %xmm3    # 0x21540
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movapd 0x1a599(%rip), %xmm2    # 0x21550
subpd %xmm2, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movq %rax, %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
movsd 0x1a533(%rip), %xmm2    # 0x21520
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x1a51b(%rip), %xmm1    # 0x21518
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/map.c
// Function: mp_dbg_chain
static void mp_dbg_chain(const mp_idx_t *mi, int32_t n_reg, const mp_reg1_t *reg, const uint64_t *a, int32_t bbit, const char *label)
{
	int32_t i, k;
	for (i = 0; i < n_reg; ++i) {
		const mp_reg1_t *r = &reg[i];
		for (k = 0; k < r->cnt; ++k) {
			uint64_t ak = a[r->off + k];
			uint64_t off = bbit > 0? (long)((ak>>32) - mi->bo[r->vid]) << bbit : r->vs + (ak>>32);
			fprintf(stderr, "%s\t%d\t%ld\t%s\t%c\t%ld\t%d\n", label, i, (long)(ak>>32), mi->nt->ctg[r->vid>>1].name, "+-"[r->vid&1], (long)off, (uint32_t)ak);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%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 -0xc(%rbp), %eax
jge 0x7168
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x7158
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
addl -0x38(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x70b3
movq -0x48(%rbp), %rax
shrq $0x20, %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x40(%rbp), %rdx
movl 0x30(%rdx), %edx
movl (%rcx,%rdx,4), %ecx
subq %rcx, %rax
movl -0x24(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x58(%rbp)
jmp 0x70ca
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x48(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x1ef1f(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq -0x48(%rbp), %r8
shrq $0x20, %r8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rsi
movl 0x30(%rsi), %esi
shrl %esi
movl %esi, %esi
imulq $0x18, %rsi, %rsi
addq %rsi, %rax
movq 0x10(%rax), %r9
movq -0x40(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x1a452(%rip), %rax     # 0x21574
movsbl (%rax,%rsi), %r11d
movq -0x50(%rbp), %r10
movq -0x48(%rbp), %rax
leaq 0x1a454(%rip), %rsi     # 0x2158a
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x21f0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x705c
jmp 0x715a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7036
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2190
movq -0x18(%rbp), %rdi
callq 0x18950
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x7bd4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c4f
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x1, -0x24(%rbp)
jle 0x7bf2
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x7bfc
movl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x7bfc
movl -0x6c(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7c1c
leaq 0x19963(%rip), %rdi     # 0x2157a
callq 0x20a0
movl $0x2, %edi
leaq 0x38(%rip), %rsi        # 0x7c60
leaq -0x68(%rbp), %rdx
movl $0x3, %ecx
callq 0xb650
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x50(%rbp), %rdi
callq 0x18a00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
leaq 0x1e7d7(%rip), %rax     # 0x26a70
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x82eb
movq 0x1dd4e(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movl -0x14(%rbp), %r8d
leaq 0x192f6(%rip), %rsi     # 0x215da
movb $0x0, %al
callq 0x21f0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %r8
movq (%rax,%r8,8), %r8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r9
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
callq 0x6230
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/align.c
// Function: mp_map2ns_opt
static inline void mp_map2ns_opt(const mp_mapopt_t *mo, ns_opt_t *no)
{
	int32_t i;
	ns_opt_init(no);
	no->go = mo->go, no->ge = mo->ge, no->io = mo->io, no->fs = mo->fs, no->xdrop = mo->xdrop, no->sc = mo->mat;
	no->ie_coef = mo->ie_coef;
	no->end_bonus = mo->end_bonus;
	no->sp_null_bonus = mo->sp_null_bonus;
	ns_opt_set_sp(no, mo->sp_model);
	for (i = 0; i < 6; ++i) no->sp[i] = (int32_t)(no->sp[i] * mo->sp_scale + .499f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f90
movq -0x8(%rbp), %rax
movl 0x64(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rcx
addq $0xa8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movss 0x78(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x80(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %esi
callq 0x3ea0
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x93cb
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cvtsi2ssl 0x20(%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movss 0x88(%rax), %xmm1
mulss %xmm1, %xmm0
movss 0x1823c(%rip), %xmm1    # 0x215e8
addss %xmm1, %xmm0
cvttss2si %xmm0, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x20(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/align.c
// Function: mp_align_seq
static int32_t mp_align_seq(void *km, const mp_mapopt_t *opt, const ns_opt_t *ns_opt0, int32_t nlen, const uint8_t *nseq, int32_t alen, const char *aseq, const uint8_t *ss, mp_cigar_t *cigar)
{
	int32_t i;
	if (nlen == alen * 3 && alen <= opt->kmer2) {
		cigar->c = ns_push_cigar(km, &cigar->n, &cigar->m, cigar->c, NS_CIGAR_M, alen);
		return mp_score_ungapped(alen, nseq, aseq, opt->asize, opt->mat);
	} else {
		ns_opt_t ns_opt = *ns_opt0;
		ns_rst_t rst;
		ns_opt.flag |= NS_F_CIGAR;
		ns_rst_init(&rst);
		ns_global_gs16b(km, (const char*)nseq, nlen, aseq, alen, &ns_opt, ss, &rst);
		//printf("%d\t%d\t%d\t%d\n", nlen, alen, rst.score, rst.n_cigar);
		for (i = 0; i < rst.n_cigar; ++i)
			cigar->c = ns_push_cigar(km, &cigar->n, &cigar->m, cigar->c, rst.cigar[i]&0xf, rst.cigar[i]>>4);
		kfree(km, rst.cigar);
		return rst.score;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x20(%rbp), %rax
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)
movl %r9d, -0x34(%rbp)
movl -0x24(%rbp), %eax
imull $0x3, -0x34(%rbp), %ecx
cmpl %ecx, %eax
jne 0x94b1
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jg 0x94b1
movq -0x10(%rbp), %rdi
movq 0x20(%rbp), %rsi
movq 0x20(%rbp), %rdx
addq $0x4, %rdx
movq 0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x34(%rbp), %r9d
xorl %r8d, %r8d
callq 0xa8b0
movq %rax, %rcx
movq 0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x94(%rax), %ecx
movq -0x18(%rbp), %r8
addq $0xa8, %r8
callq 0xa990
movl %eax, -0x4(%rbp)
jmp 0x9598
movq -0x20(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movl $0x60, %edx
callq 0x2200
movl -0x98(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x98(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x93e0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
movq 0x10(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq 0x18(%rbp), %r10
leaq -0x98(%rbp), %r9
leaq -0xb8(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xbb40
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xb8(%rbp), %eax
jge 0x957f
movq -0x10(%rbp), %rdi
movq 0x20(%rbp), %rsi
movq 0x20(%rbp), %rdx
addq $0x4, %rdx
movq 0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0xa0(%rbp), %rax
movslq -0x38(%rbp), %r8
movl (%rax,%r8,4), %r8d
andl $0xf, %r8d
movq -0xa0(%rbp), %rax
movslq -0x38(%rbp), %r9
movl (%rax,%r9,4), %r9d
shrl $0x4, %r9d
callq 0xa8b0
movq %rax, %rcx
movq 0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x951b
movq -0x10(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0xac90
movl -0xa8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/align.c
// Function: mp_extra_gen
static void mp_extra_gen(void *km, mp_reg1_t *r, mp_cigar_t *cigar, int32_t score)
{
	int32_t cap;
	cap = cigar->n + sizeof(mp_extra_t) / 4;
	r->p = Kcalloc(0, mp_extra_t, cap); // allocate globally, not from km
	r->p->dp_score = score;
	r->p->n_cigar = r->p->m_cigar = cigar->n;
	memcpy(r->p->cigar, cigar->c, cigar->n * sizeof(uint32_t));
	kfree(km, cigar->c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq (%rax), %rax
addq $0xc, %rax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0x30, %edx
callq 0xab60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movslq (%rax), %rdx
shlq $0x2, %rdx
callq 0x2200
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xac90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)