LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/KeccakP-1600-opt64.c
// Function: KeccakP1600_OverwriteBytesInLane
void KeccakP1600_OverwriteBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
#ifdef KeccakP1600_useLaneComplementing
    if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20)) {
        unsigned int i;
        for(i=0; i<length; i++)
            ((unsigned char*)state)[lanePosition*8+offset+i] = ~data[i];
    }
    else
#endif
    {
        memcpy((unsigned char*)state+lanePosition*8+offset, data, length);
    }
#else
#error "Not yet implemented"
#endif
}

// Assembly:
cmpl $0x14, %esi
ja 0x5a51
movl $0x121106, %eax         # imm = 0x121106
btl %esi, %eax
jae 0x5a51
testl %r8d, %r8d
je 0x5a50
movl %r8d, %eax
leal (%rcx,%rsi,8), %ecx
xorl %esi, %esi
movb (%rdx,%rsi), %r8b
notb %r8b
leal (%rcx,%rsi), %r9d
movb %r8b, (%rdi,%r9)
incq %rsi
cmpq %rsi, %rax
jne 0x5a39
retq
shll $0x3, %esi
addq %rsi, %rdi
movl %ecx, %eax
addq %rdi, %rax
movl %r8d, %ecx
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x5650
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/KeccakP-1600-opt64.c
// Function: KeccakP1600_OverwriteLanes
void KeccakP1600_OverwriteLanes(void *state, const unsigned char *data, unsigned int laneCount)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
#ifdef KeccakP1600_useLaneComplementing
    unsigned int lanePosition;

    for(lanePosition=0; lanePosition<laneCount; lanePosition++)
        if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
            ((UINT64*)state)[lanePosition] = ~((const UINT64*)data)[lanePosition];
        else
            ((UINT64*)state)[lanePosition] = ((const UINT64*)data)[lanePosition];
#else
    memcpy(state, data, laneCount*8);
#endif
#else
#error "Not yet implemented"
#endif
}

// Assembly:
testl %edx, %edx
je 0x5a9f
movl %edx, %eax
xorl %ecx, %ecx
movl $0x121106, %edx         # imm = 0x121106
cmpl $0x14, %ecx
ja 0x5a99
btl %ecx, %edx
jae 0x5a99
movq (%rsi,%rcx,8), %r8
notq %r8
movq %r8, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5a7a
jmp 0x5a9f
movq (%rsi,%rcx,8), %r8
jmp 0x5a8b
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/KeccakP-1600-opt64.c
// Function: KeccakP1600_OverwriteWithZeroes
void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
#ifdef KeccakP1600_useLaneComplementing
    unsigned int lanePosition;

    for(lanePosition=0; lanePosition<byteCount/8; lanePosition++)
        if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
            ((UINT64*)state)[lanePosition] = ~0;
        else
            ((UINT64*)state)[lanePosition] = 0;
    if (byteCount%8 != 0) {
        lanePosition = byteCount/8;
        if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
            memset((unsigned char*)state+lanePosition*8, 0xFF, byteCount%8);
        else
            memset((unsigned char*)state+lanePosition*8, 0, byteCount%8);
    }
#else
    memset(state, 0, byteCount);
#endif
#else
#error "Not yet implemented"
#endif
}

// Assembly:
movl %esi, %eax
shrl $0x3, %eax
cmpl $0x8, %esi
jae 0x5c28
movl %esi, %ecx
andl $0x7, %ecx
je 0x5c67
movl %esi, %edx
andl $-0x28, %edx
cmpl $0x40, %edx
je 0x5c16
cmpl $0x14, %eax
ja 0x5c68
movl $0x120006, %edx         # imm = 0x120006
btl %eax, %edx
jae 0x5c68
andl $-0x8, %esi
addq %rsi, %rdi
movl %ecx, %edx
movl $0xff, %esi
jmp 0x5070
movl %eax, %ecx
xorl %edx, %edx
movl $0x120006, %r8d         # imm = 0x120006
movl %edx, %r10d
andl $0x7ffffffb, %r10d      # imm = 0x7FFFFFFB
movq $-0x1, %r9
cmpl $0x8, %r10d
je 0x5c54
cmpl $0x14, %edx
ja 0x5c62
btl %edx, %r8d
jae 0x5c62
movq %r9, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x5c32
jmp 0x5bf6
xorl %r9d, %r9d
jmp 0x5c54
retq
andl $-0x8, %esi
addq %rsi, %rdi
movl %ecx, %edx
xorl %esi, %esi
jmp 0x5070
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/KeccakP-1600-opt64.c
// Function: KeccakP1600_ExtractLanes
void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    memcpy(data, state, laneCount*8);
#else
    unsigned int i;

    for(i=0; i<laneCount; i++)
        fromWordToBytes(data+(i*8), ((const UINT64*)state)[i]);
#endif
#ifdef KeccakP1600_useLaneComplementing
    if (laneCount > 1) {
        ((UINT64*)data)[ 1] = ~((UINT64*)data)[ 1];
        if (laneCount > 2) {
            ((UINT64*)data)[ 2] = ~((UINT64*)data)[ 2];
            if (laneCount > 8) {
                ((UINT64*)data)[ 8] = ~((UINT64*)data)[ 8];
                if (laneCount > 12) {
                    ((UINT64*)data)[12] = ~((UINT64*)data)[12];
                    if (laneCount > 17) {
                        ((UINT64*)data)[17] = ~((UINT64*)data)[17];
                        if (laneCount > 20) {
                            ((UINT64*)data)[20] = ~((UINT64*)data)[20];
                        }
                    }
                }
            }
        }
    }
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rsi
leal (,%r14,8), %edx
movq %rbx, %rdi
callq 0x5650
cmpl $0x2, %r14d
jb 0xd453
notq 0x8(%rbx)
je 0xd453
notq 0x10(%rbx)
cmpl $0x9, %r14d
jb 0xd453
notq 0x40(%rbx)
cmpl $0xd, %r14d
jb 0xd453
notq 0x60(%rbx)
cmpl $0x12, %r14d
jb 0xd453
notq 0x88(%rbx)
cmpl $0x15, %r14d
jb 0xd453
notq 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/twine80n6t4clocv2/vperm/encrypt.c
// Function: load_partial_block
void load_partial_block(word* dst, const unsigned char* m, int len, unsigned choice)
{
    unsigned char temp[STATE_LEN];
    if(choice == ZERO_APPEND){
        memcpy(temp, m, len);
        memset(temp+len, 0, STATE_LEN-len);
        *dst = LOADS(temp);
    }
    else if(choice == ONE_ZERO_PADDING){
        memcpy(temp, m, len);
        memset(temp+len, 0, STATE_LEN-len);
        if(len < STATE_LEN)
            temp[len] = 0x80;
        *dst = LOADS(temp);
    }
    else if(choice == ZERO_PREPEND){
        memcpy(temp+STATE_LEN-len, m, len);
        memset(temp, 0, STATE_LEN-len);
        *dst = LOADS(temp);
    }
    else if(choice == PARAM_OZP){
        temp[0] = PARAM;
        memcpy(temp+1, m, len);
        memset(temp+len+1, 0, STATE_LEN-len-1);
        if(len < (STATE_LEN-1))
            temp[len+1] = 0x80;
        *dst = LOADS(temp);
    }
    else{
        // do nothing
    }
}

// Assembly:
cmpl $0x3, %ecx
ja 0x163e
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %ecx, %eax
leaq 0x1ad4(%rip), %rcx      # 0x3018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq %ebp, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x1080
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
movl $0x8, %eax
subl %ebp, %eax
movslq %eax, %rdx
jmp 0x160f
movslq %ebp, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x1080
addq %rsp, %r14
addq $0x8, %r14
movl $0x8, %eax
subl %ebp, %eax
movslq %eax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1030
cmpl $0x7, %ebp
jg 0x1616
movb $-0x80, (%r14)
jmp 0x1616
leaq 0x9(%rsp), %rdi
movb $-0x34, -0x1(%rdi)
movslq %ebp, %r14
movq %r14, %rdx
callq 0x1080
leaq (%rsp,%r14), %rdi
addq $0x9, %rdi
movl $0x7, %eax
subl %r14d, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
cmpl $0x6, %r14d
jg 0x1616
leaq 0x8(%rsp), %rax
movb $-0x80, 0x1(%r14,%rax)
jmp 0x1616
movslq %ebp, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
subq %rdx, %rdi
addq $0x8, %rdi
callq 0x1080
movl $0x8, %eax
subl %ebp, %eax
movslq %eax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1030
vmovq 0x8(%rsp), %xmm0
vpsrlw $0x4, %xmm0, %xmm1
vpunpcklbw %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
vpbroadcastb 0x19e6(%rip), %xmm1 # 0x3014
vpand %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/page_fault2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);
	unsigned long pgsize = getpagesize();

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

	while (1) {
		unsigned long i;

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

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

		munmap(c, MEMSIZE);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps 0x6ca(%rip), %xmm0      # 0x3350
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21c0
movl %eax, %ebp
callq 0x2270
testl %ebp, %ebp
js 0x2d55
movl %eax, %r14d
movl $0x8000000, %esi        # imm = 0x8000000
movl %ebp, %edi
callq 0x2110
testl %eax, %eax
jne 0x2d74
movq %rsp, %rdi
callq 0x2080
movl $0x8000000, %esi        # imm = 0x8000000
xorl %edi, %edi
movl $0x3, %edx
movl $0x2, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x20e0
cmpq $-0x1, %rax
je 0x2d36
movslq %r14d, %r14
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq (%rbx)
addq %r14, %rcx
cmpq $0x8000000, %rcx        # imm = 0x8000000
jb 0x2cf4
movl $0x8000000, %esi        # imm = 0x8000000
movq %rax, %rdi
callq 0x21d0
movl $0x8000000, %esi        # imm = 0x8000000
xorl %edi, %edi
movl $0x3, %edx
movl $0x2, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x20e0
cmpq $-0x1, %rax
jne 0x2cf2
leaq 0x5ff(%rip), %rdi       # 0x333c
leaq 0x595(%rip), %rsi       # 0x32d9
leaq 0x5a2(%rip), %rcx       # 0x32ed
movl $0x19, %edx
callq 0x2120
leaq 0x575(%rip), %rdi       # 0x32d1
leaq 0x576(%rip), %rsi       # 0x32d9
leaq 0x583(%rip), %rcx       # 0x32ed
movl $0x10, %edx
callq 0x2120
leaq 0x5a5(%rip), %rdi       # 0x3320
leaq 0x557(%rip), %rsi       # 0x32d9
leaq 0x564(%rip), %rcx       # 0x32ed
movl $0x11, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/main.c
// Function: yes_or_no
static inline void yes_or_no(mm_mapopt_t *opt, int64_t flag, int long_idx, const char *arg, int yes_to_set)
{
	if (yes_to_set) {
		if (strcmp(arg, "yes") == 0 || strcmp(arg, "y") == 0) opt->flag |= flag;
		else if (strcmp(arg, "no") == 0 || strcmp(arg, "n") == 0) opt->flag &= ~flag;
		else fprintf(stderr, "[WARNING]\033[1;31m option '--%s' only accepts 'yes' or 'no'.\033[0m\n", long_options[long_idx].name);
	} else {
		if (strcmp(arg, "yes") == 0 || strcmp(arg, "y") == 0) opt->flag &= ~flag;
		else if (strcmp(arg, "no") == 0 || strcmp(arg, "n") == 0) opt->flag |= flag;
		else fprintf(stderr, "[WARNING]\033[1;31m option '--%s' only accepts 'yes' or 'no'.\033[0m\n", long_options[long_idx].name);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r12d
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27372(%rip), %rsi     # 0x2c9bf
movq %rcx, %rdi
callq 0x2240
testl %r12d, %r12d
je 0x5675
testl %eax, %eax
je 0x56c2
movzbl (%r15), %eax
cmpl $0x6e, %eax
je 0x5690
cmpl $0x79, %eax
jne 0x56ce
cmpb $0x0, 0x1(%r15)
je 0x56c2
jmp 0x56ce
testl %eax, %eax
je 0x56a5
movzbl (%r15), %eax
cmpl $0x6e, %eax
je 0x56ad
cmpl $0x79, %eax
jne 0x56d7
cmpb $0x0, 0x1(%r15)
je 0x56a5
jmp 0x56d7
cmpb $0x6f, 0x1(%r15)
jne 0x569e
cmpb $0x0, 0x2(%r15)
je 0x56a5
cmpb $0x0, 0x1(%r15)
jne 0x56ce
notq %rbx
andq %rbx, (%r14)
jmp 0x56c5
cmpb $0x6f, 0x1(%r15)
jne 0x56bb
cmpb $0x0, 0x2(%r15)
je 0x56c2
cmpb $0x0, 0x1(%r15)
jne 0x56d7
orq %rbx, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x2906
jmp 0x56c5
movl %ebp, %edi
callq 0x2933
jmp 0x56c5
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/main.c
// Function: mm_parse_num2
static inline int64_t mm_parse_num2(const char *str, char **q)
{
	double x;
	char *p;
	x = strtod(str, &p);
	if (*p == 'G' || *p == 'g') x *= 1e9, ++p;
	else if (*p == 'M' || *p == 'm') x *= 1e6, ++p;
	else if (*p == 'K' || *p == 'k') x *= 1e3, ++p;
	if (q) *q = p;
	return (int64_t)(x + .499);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x20d0
movq (%r14), %rax
movzbl (%rax), %ecx
addl $-0x47, %ecx
cmpl $0x26, %ecx
ja 0x574f
movabsq $0x100000001, %rdx      # imm = 0x100000001
btq %rcx, %rdx
jb 0x5744
movabsq $0x1000000010, %rdx     # imm = 0x1000000010
btq %rcx, %rdx
jb 0x573a
movabsq $0x4000000040, %rdx     # imm = 0x4000000040
btq %rcx, %rdx
jae 0x574f
mulsd 0x258d8(%rip), %xmm0    # 0x2b010
jmp 0x574c
mulsd 0x258c6(%rip), %xmm0    # 0x2b008
jmp 0x574c
mulsd 0x258cc(%rip), %xmm0    # 0x2b018
incq %rax
testq %rbx, %rbx
je 0x5757
movq %rax, (%rbx)
addsd 0x258c1(%rip), %xmm0    # 0x2b020
cvttsd2si %xmm0, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/options.c
// Function: mm_mapopt_update
void mm_mapopt_update(mm_mapopt_t *opt, const mm_idx_t *mi)
{
	if ((opt->flag & MM_F_SPLICE_FOR) || (opt->flag & MM_F_SPLICE_REV))
		opt->flag |= MM_F_SPLICE;
	if (opt->mid_occ <= 0) {
		opt->mid_occ = mm_idx_cal_max_occ(mi, opt->mid_occ_frac);
		if (opt->mid_occ < opt->min_mid_occ)
			opt->mid_occ = opt->min_mid_occ;
		if (opt->max_mid_occ > opt->min_mid_occ && opt->mid_occ > opt->max_mid_occ)
			opt->mid_occ = opt->max_mid_occ;
	}
	if (opt->bw_long < opt->bw) opt->bw_long = opt->bw;
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s::%.3f*%.2f] mid_occ = %d\n", __func__, realtime() - mm_realtime0, cputime() / (realtime() - mm_realtime0), opt->mid_occ);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testl $0x300, %eax            # imm = 0x300
je 0x6127
orq $0x80, %rax
movq %rax, (%rbx)
cmpl $0x0, 0xd4(%rbx)
jg 0x6163
movss 0xc4(%rbx), %xmm0
movq %rsi, %rdi
callq 0x7306
movl 0xcc(%rbx), %ecx
movl 0xd0(%rbx), %edx
cmpl %ecx, %eax
cmovlel %ecx, %eax
cmpl %edx, %eax
movl %edx, %esi
cmovll %eax, %esi
cmpl %ecx, %edx
cmovlel %eax, %esi
movl %esi, 0xd4(%rbx)
movl 0x14(%rbx), %eax
cmpl %eax, 0x18(%rbx)
jge 0x616e
movl %eax, 0x18(%rbx)
leaq 0x3058b(%rip), %rax     # 0x36700
cmpl $0x3, (%rax)
jge 0x617c
popq %rbx
retq
addq $0xd4, %rbx
movq %rbx, %rdi
callq 0x299f
jmp 0x617a
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_init
mm_idx_t *mm_idx_init(int w, int k, int b, int flag)
{
	mm_idx_t *mi;
	if (k*2 < b) b = k * 2;
	if (w < 1) w = 1;
	mi = (mm_idx_t*)calloc(1, sizeof(mm_idx_t));
	mi->w = w, mi->k = k, mi->b = b, mi->flag = flag;
	mi->B = (mm_idx_bucket_t*)calloc(1<<b, sizeof(mm_idx_bucket_t));
	if (!(mm_dbg_flag & 1)) mi->km = km_init();
	return mi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leal (%r14,%r14), %r12d
cmpl %edx, %r12d
cmovgel %edx, %r12d
cmpl $0x2, %edi
movl $0x1, %r13d
cmovll %r13d, %r15d
movl $0x1, %edi
movl $0x60, %esi
callq 0x2230
movq %rax, %rbx
movl %r15d, 0x4(%rax)
movl %r14d, 0x8(%rax)
movl %r12d, (%rax)
movl %ebp, 0xc(%rax)
movl %r12d, %ecx
shll %cl, %r13d
movslq %r13d, %rdi
movl $0x30, %esi
callq 0x2230
movq %rax, 0x30(%rbx)
leaq 0x2fdfb(%rip), %rax     # 0x36928
testb $0x1, (%rax)
jne 0x6b3b
callq 0x1252f
movq %rax, 0x50(%rbx)
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_O3/lh3[P]minimap2/index.c
// Function: mm_idx_destroy
void mm_idx_destroy(mm_idx_t *mi)
{
	uint32_t i;
	if (mi == 0) return;
	if (mi->h) kh_destroy(str, (khash_t(str)*)mi->h);
	if (mi->B) {
		for (i = 0; i < 1U<<mi->b; ++i) {
			free(mi->B[i].p);
			free(mi->B[i].a.a);
			kh_destroy(idx, (idxhash_t*)mi->B[i].h);
		}
	}
	if (mi->spsc) free(mi->spsc);
	if (mi->I) {
		for (i = 0; i < mi->n_seq; ++i)
			free(mi->I[i].a);
		free(mi->I);
	}
	if (mi->J) {
		for (i = 0; i < mi->n_seq; ++i)
			free(mi->J[i].a);
		free(mi->J);
	}
	if (!mi->km) {
		for (i = 0; i < mi->n_seq; ++i)
			free(mi->seq[i].name);
		free(mi->seq);
	} else km_destroy(mi->km);
	free(mi->B); free(mi->S); free(mi);
}

// Assembly:
testq %rdi, %rdi
je 0x6ca6
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %r14
testq %r14, %r14
je 0x6b92
movq 0x18(%r14), %rsi
xorl %edi, %edi
callq 0x12587
movq 0x10(%r14), %rsi
xorl %edi, %edi
callq 0x12587
movq 0x20(%r14), %rsi
xorl %edi, %edi
callq 0x12587
xorl %edi, %edi
movq %r14, %rsi
callq 0x12587
cmpq $0x0, 0x30(%rbx)
je 0x6c0e
movl $0x1, %r15d
leal -0x1(%r15), %eax
movq 0x30(%rbx), %rcx
shlq $0x4, %rax
leaq (%rax,%rax,2), %r14
movq 0x20(%rcx,%r14), %rdi
callq 0x2040
movq 0x30(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
callq 0x2040
movq 0x30(%rbx), %rax
movq 0x28(%rax,%r14), %r14
testq %r14, %r14
je 0x6c00
movq 0x18(%r14), %rsi
xorl %edi, %edi
callq 0x12587
movq 0x10(%r14), %rsi
xorl %edi, %edi
callq 0x12587
movq 0x20(%r14), %rsi
xorl %edi, %edi
callq 0x12587
xorl %edi, %edi
movq %r14, %rsi
callq 0x12587
movb (%rbx), %cl
movl %r15d, %eax
shrl %cl, %eax
incl %r15d
testl %eax, %eax
je 0x6b9f
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x6c1c
callq 0x2040
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6c59
cmpl $0x0, 0x10(%rbx)
je 0x6c54
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x38(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2040
incq %r15
movl 0x10(%rbx), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x6c34
movq 0x38(%rbx), %rdi
callq 0x2040
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x6c96
cmpl $0x0, 0x10(%rbx)
je 0x6c91
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x48(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2040
incq %r15
movl 0x10(%rbx), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x6c71
movq 0x48(%rbx), %rdi
callq 0x2040
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x6ca7
callq 0x12549
jmp 0x6cd8
retq
cmpl $0x0, 0x10(%rbx)
je 0x6ccf
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2040
incq %r15
movl 0x10(%rbx), %eax
addq $0x18, %r14
cmpq %rax, %r15
jb 0x6cb3
movq 0x20(%rbx), %rdi
callq 0x2040
movq 0x30(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_index_name
int mm_idx_index_name(mm_idx_t *mi)
{
	khash_t(str) *h;
	uint32_t i;
	int has_dup = 0, absent;
	if (mi->h) return 0;
	h = kh_init(str);
	for (i = 0; i < mi->n_seq; ++i) {
		khint_t k;
		k = kh_put(str, h, mi->seq[i].name, &absent);
		if (absent) kh_val(h, k) = i;
		else has_dup = 1;
	}
	mi->h = h;
	if (has_dup && mm_verbose >= 2)
		fprintf(stderr, "[WARNING] some database sequences have identical sequence names\n");
	return has_dup;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq $0x0, 0x58(%rdi)
je 0x6e11
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
xorl %ebx, %ebx
movl $0x1, %esi
movl $0x28, %edx
xorl %edi, %edi
callq 0x124ec
movq %rax, %r15
cmpl $0x0, 0x10(%r14)
je 0x6e97
leaq 0x4(%rsp), %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%r14), %rax
movq (%rax,%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x6ea2
cmpl $0x0, 0x4(%rsp)
je 0x6e60
movq 0x20(%r15), %rcx
movl %eax, %eax
movl %ebp, (%rcx,%rax,4)
jmp 0x6e65
movl $0x1, %ebx
incq %rbp
movl 0x10(%r14), %eax
addq $0x18, %r13
cmpq %rax, %rbp
jb 0x6e3b
movq %r15, 0x58(%r14)
testl %ebx, %ebx
je 0x6e00
leaq 0x2f87c(%rip), %rax     # 0x36700
cmpl $0x2, (%rax)
jl 0x6e00
callq 0x2d86
jmp 0x6e00
movq %r15, 0x58(%r14)
xorl %ebx, %ebx
jmp 0x6e00
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_name2id
int mm_idx_name2id(const mm_idx_t *mi, const char *name)
{
	khash_t(str) *h = (khash_t(str)*)mi->h;
	khint_t k;
	if (h == 0) return -2;
	k = kh_get(str, h, name);
	return k == kh_end(h)? -1 : kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x58(%rdi), %rbx
testq %rbx, %rbx
je 0x710b
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x7115
leal -0x1(%rcx), %edi
movsbl (%rsi), %r13d
testl %r13d, %r13d
movq %rcx, 0x10(%rsp)
je 0x711d
movb 0x1(%rsi), %al
testb %al, %al
je 0x7120
leaq 0x2(%rsi), %rcx
movl %r13d, %edx
shll $0x5, %edx
subl %r13d, %edx
movsbl %al, %r13d
addl %edx, %r13d
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x70f0
jmp 0x7120
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x71c1
xorl %r15d, %r15d
jmp 0x71ad
xorl %r13d, %r13d
andl %edi, %r13d
movq 0x10(%rbx), %rdx
movl $0x1, %r14d
movl %r13d, %r15d
movq %rbx, 0x20(%rsp)
movl %edi, 0xc(%rsp)
movq %rsi, 0x18(%rsp)
movl %r15d, %eax
shrl $0x4, %eax
movl (%rdx,%rax,4), %r12d
leal (%r15,%r15), %ebp
andl $0x1e, %ebp
movl %r12d, %eax
movl %ebp, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x719b
testb $0x1, %al
jne 0x7186
movq 0x18(%rbx), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %rdi
movq %rdx, %rbx
callq 0x2240
movq %rbx, %rdx
movl 0xc(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rbx
testl %eax, %eax
je 0x719b
addl %r14d, %r15d
andl %edi, %r15d
incl %r14d
cmpl %r13d, %r15d
jne 0x713e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x71c1
movl %ebp, %ecx
shrl %cl, %r12d
testb $0x3, %r12b
movq 0x10(%rsp), %rcx
cmovnel %ecx, %r15d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r15d
je 0x71c1
movq 0x20(%rbx), %rax
movl %r15d, %ecx
movl (%rax,%rcx,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_getseq
int mm_idx_getseq(const mm_idx_t *mi, uint32_t rid, uint32_t st, uint32_t en, uint8_t *seq)
{
	uint64_t i, st1, en1;
	if (rid >= mi->n_seq || st >= mi->seq[rid].len) return -1;
	if (en > mi->seq[rid].len) en = mi->seq[rid].len;
	st1 = mi->seq[rid].offset + st;
	en1 = mi->seq[rid].offset + en;
	for (i = st1; i < en1; ++i)
		seq[i - st1] = mm_seq4_get(mi->S, i);
	return en - st;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, 0x10(%rdi)
jbe 0x724a
movl %ecx, %r9d
movq 0x20(%rdi), %rcx
movl %esi, %esi
leaq (%rsi,%rsi,2), %rsi
movl 0x10(%rcx,%rsi,8), %r10d
cmpl %edx, %r10d
jbe 0x724a
pushq %rbx
cmpl %r9d, %r10d
cmovbl %r10d, %r9d
movq 0x8(%rcx,%rsi,8), %rax
movl %edx, %ecx
leaq (%rax,%rcx), %rsi
leaq (%rax,%r9), %r10
cmpq %r10, %rsi
jae 0x7243
movq %r9, %r10
subq %rcx, %r10
addl %edx, %eax
shll $0x2, %eax
xorl %r11d, %r11d
leaq (%rsi,%r11), %rcx
movq 0x28(%rdi), %rbx
shrq $0x3, %rcx
movl (%rbx,%rcx,4), %ebx
movl %eax, %ecx
andb $0x1c, %cl
shrl %cl, %ebx
andb $0xf, %bl
movb %bl, (%r8,%r11)
incq %r11
addl $0x4, %eax
cmpq %r11, %r10
jne 0x721b
subl %edx, %r9d
movl %r9d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_getseq_rev
int mm_idx_getseq_rev(const mm_idx_t *mi, uint32_t rid, uint32_t st, uint32_t en, uint8_t *seq)
{
	uint64_t i, st1, en1;
	const mm_idx_seq_t *s;
	if (rid >= mi->n_seq || st >= mi->seq[rid].len) return -1;
	s = &mi->seq[rid];
	if (en > s->len) en = s->len;
	st1 = s->offset + (s->len - en);
	en1 = s->offset + (s->len - st);
	for (i = st1; i < en1; ++i) {
		uint8_t c = mm_seq4_get(mi->S, i);
		seq[en1 - i - 1] = c < 4? 3 - c : c;
	}
	return en - st;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, 0x10(%rdi)
jbe 0x72e3
movl %ecx, %r9d
movq 0x20(%rdi), %rcx
movl %esi, %esi
leaq (%rsi,%rsi,2), %r11
movl 0x10(%rcx,%r11,8), %esi
movl %esi, %r10d
subl %edx, %r10d
jbe 0x72e3
pushq %rbx
leaq (%rcx,%r11,8), %rax
cmpl %r9d, %esi
cmovbl %esi, %r9d
movq 0x8(%rax), %rcx
movl %esi, %r11d
subl %r9d, %r11d
leaq (%rcx,%r11), %rax
leaq (%rcx,%r10), %rbx
cmpq %rbx, %rax
jae 0x72dc
subq %r11, %r10
addl %ecx, %esi
subl %r9d, %esi
shll $0x2, %esi
movq 0x28(%rdi), %rcx
movq %rax, %r11
shrq $0x3, %r11
movl (%rcx,%r11,4), %r11d
movl %esi, %ecx
andb $0x1c, %cl
shrl %cl, %r11d
andl $0xf, %r11d
movb $0x3, %cl
subb %r11b, %cl
cmpl $0x4, %r11d
movzbl %cl, %ecx
cmovael %r11d, %ecx
movb %cl, -0x1(%r8,%r10)
incq %rax
addl $0x4, %esi
decq %r10
jne 0x72a1
subl %edx, %r9d
movl %r9d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_cal_max_occ
int32_t mm_idx_cal_max_occ(const mm_idx_t *mi, float f)
{
	int i;
	size_t n = 0;
	uint32_t thres;
	khint_t *a, k;
	if (f <= 0.) return INT32_MAX;
	for (i = 0; i < 1<<mi->b; ++i)
		if (mi->B[i].h) n += kh_size((idxhash_t*)mi->B[i].h);
	if (n == 0) return INT32_MAX;
	a = (uint32_t*)malloc(n * 4);
	for (i = n = 0; i < 1<<mi->b; ++i) {
		idxhash_t *h = (idxhash_t*)mi->B[i].h;
		if (h == 0) continue;
		for (k = 0; k < kh_end(h); ++k) {
			if (!kh_exist(h, k)) continue;
			a[n++] = kh_key(h, k)&1? 1 : (uint32_t)kh_val(h, k);
		}
	}
	thres = ks_ksmall_uint32_t(n, a, (uint32_t)((1. - f) * n)) + 1;
	free(a);
	return thres;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x747d
movq %rdi, %r14
movl (%rdi), %r15d
movl $0x1, %edx
movl $0x1, %r12d
movl %r15d, %ecx
shll %cl, %r12d
cmpl $0x1f, %r15d
je 0x747d
cvtss2sd %xmm0, %xmm0
movq 0x30(%r14), %rax
cmpl $0x2, %r12d
cmovgel %r12d, %edx
shlq $0x4, %rdx
leaq (%rdx,%rdx,2), %rcx
xorl %edx, %edx
xorl %edi, %edi
movq 0x28(%rax,%rdx), %rsi
testq %rsi, %rsi
je 0x7370
movl 0x4(%rsi), %esi
addq %rsi, %rdi
addq $0x30, %rdx
cmpq %rdx, %rcx
jne 0x7360
testq %rdi, %rdi
je 0x747d
movsd %xmm0, 0x8(%rsp)
shlq $0x2, %rdi
callq 0x22f0
movq %rax, %rbx
cmpl $0x1f, %r15d
jne 0x73a7
xorl %edi, %edi
movsd 0x8(%rsp), %xmm2
jmp 0x7431
movq 0x30(%r14), %rax
cmpl $0x2, %r12d
movl $0x1, %edx
cmovgel %r12d, %edx
xorl %esi, %esi
xorl %edi, %edi
movsd 0x8(%rsp), %xmm2
leaq (%rsi,%rsi,2), %rcx
shlq $0x4, %rcx
movq 0x28(%rax,%rcx), %r8
testq %r8, %r8
je 0x7429
movl (%r8), %r9d
testq %r9, %r9
je 0x7429
movq 0x10(%r8), %r10
xorl %r11d, %r11d
xorl %r14d, %r14d
movq %r14, %rcx
shrq $0x4, %rcx
movl (%r10,%rcx,4), %ebp
movl %r11d, %ecx
andb $0x1e, %cl
shrl %cl, %ebp
testb $0x3, %bpl
jne 0x741d
movq 0x18(%r8), %r15
movl $0x1, %ecx
testb $0x1, (%r15,%r14,8)
jne 0x7417
movq 0x20(%r8), %rcx
movl (%rcx,%r14,8), %ecx
movl %ecx, (%rbx,%rdi,4)
incq %rdi
incq %r14
addl $0x2, %r11d
cmpq %r9, %r14
jb 0x73e6
incq %rsi
cmpq %rdx, %rsi
jne 0x73c2
movsd 0x23bef(%rip), %xmm0    # 0x2b028
movq %rdi, %xmm1
punpckldq 0x25c8a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x25c92(%rip), %xmm1    # 0x2d0e0
subsd %xmm2, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movl %eax, %edx
movq %rbx, %rsi
callq 0x5d8d
movl %eax, %ebp
incl %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_gen
mm_idx_t *mm_idx_gen(mm_bseq_file_t *fp, int w, int k, int b, int flag, int mini_batch_size, int n_threads, uint64_t batch_size)
{
	pipeline_t pl;
	if (fp == 0 || mm_bseq_eof(fp)) return 0;
	memset(&pl, 0, sizeof(pipeline_t));
	pl.mini_batch_size = (uint64_t)mini_batch_size < batch_size? mini_batch_size : batch_size;
	pl.batch_size = batch_size;
	pl.fp = fp;
	pl.mi = mm_idx_init(w, k, b, flag);

	kt_pipeline(n_threads < 3? n_threads : 3, worker_pipeline, &pl, 3);
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s::%.3f*%.2f] collected minimizers\n", __func__, realtime() - mm_realtime0, cputime() / (realtime() - mm_realtime0));

	mm_idx_post(pl.mi, n_threads);
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s::%.3f*%.2f] sorted minimizers\n", __func__, realtime() - mm_realtime0, cputime() / (realtime() - mm_realtime0));

	return pl.mi;
}

// Assembly:
testq %rdi, %rdi
je 0x74c1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0x136fe
testl %eax, %eax
je 0x74c4
xorl %eax, %eax
jmp 0x7561
xorl %eax, %eax
retq
movq 0x68(%rsp), %rax
movl 0x60(%rsp), %r8d
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movslq %ebx, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq $0x0, 0x10(%rdx)
movl %ecx, (%rdx)
movq %rax, 0x8(%rdx)
movq %r13, 0x18(%rdx)
movq %rdx, %rbx
movl %r12d, %edi
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r8d, %ebp
callq 0x6ac4
movq %rax, 0x20(%rbx)
cmpl $0x3, %ebp
movl $0x3, %edi
cmovll %ebp, %edi
leaq 0x5f(%rip), %rsi        # 0x757e
movq %rbx, %rdx
movl $0x3, %ecx
callq 0x12278
leaq 0x2f1cd(%rip), %rbx     # 0x36700
cmpl $0x3, (%rbx)
jge 0x7570
movq 0x20(%rsp), %rdx
movb (%rdx), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
leaq 0x3355(%rip), %rsi      # 0xa8a5
movl %ebp, %edi
callq 0x120b0
cmpl $0x3, (%rbx)
jge 0x7577
movq 0x20(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2da2
jmp 0x7538
callq 0x2e0f
jmp 0x755c
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_build
mm_idx_t *mm_idx_build(const char *fn, int w, int k, int flag, int n_threads) // a simpler interface; deprecated
{
	mm_bseq_file_t *fp;
	mm_idx_t *mi;
	fp = mm_bseq_open(fn);
	if (fp == 0) return 0;
	mi = mm_idx_gen(fp, w, k, 14, flag, 1<<18, n_threads, UINT64_MAX);
	mm_bseq_close(fp);
	return mi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
callq 0x12ff7
testq %rax, %rax
je 0x7a0c
movq %rax, %r14
movq %rax, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl $0xe, %ecx
movl %ebp, %r8d
movl $0x40000, %r9d          # imm = 0x40000
pushq $-0x1
pushq %rbx
callq 0x748c
addq $0x10, %rsp
movq %rax, %rbx
movq %r14, %rdi
callq 0x13060
movq %rbx, %rax
jmp 0x7a0e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_add
static void mm_idx_add(mm_idx_t *mi, int n, const mm128_t *a)
{
	int i, mask = (1<<mi->b) - 1;
	for (i = 0; i < n; ++i) {
		mm128_v *p = &mi->B[a[i].x>>8&mask].a;
		kv_push(mm128_t, 0, *p, a[i]);
	}
}

// Assembly:
testl %esi, %esi
jle 0x7d63
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movb (%rdi), %cl
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
shll %cl, %r15d
notl %r15d
movl %esi, %r12d
shlq $0x4, %r12
xorl %r13d, %r13d
movq 0x30(%r14), %rax
movl 0x1(%rbx,%r13), %ecx
andl %r15d, %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rbp
movq (%rax,%rdx), %rcx
cmpq 0x8(%rax,%rdx), %rcx
jne 0x7d31
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
movl $0x2, %eax
cmoveq %rax, %rdx
movq %rdx, 0x8(%rbp)
movq 0x10(%rbp), %rsi
shlq $0x4, %rdx
xorl %edi, %edi
callq 0x12755
movq %rax, 0x10(%rbp)
movq (%rbp), %rcx
jmp 0x7d35
movq 0x10(%rbp), %rax
leaq (%rbx,%r13), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rbp)
shlq $0x4, %rcx
movups (%rdx), %xmm0
movups %xmm0, (%rax,%rcx)
addq $0x10, %r13
cmpq %r13, %r12
jne 0x7ce1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_reader_open
mm_idx_reader_t *mm_idx_reader_open(const char *fn, const mm_idxopt_t *opt, const char *fn_out)
{
	int64_t is_idx;
	mm_idx_reader_t *r;
	is_idx = mm_idx_is_idx(fn);
	if (is_idx < 0) return 0; // failed to open the index
	r = (mm_idx_reader_t*)calloc(1, sizeof(mm_idx_reader_t));
	r->is_idx = is_idx;
	if (opt) r->opt = *opt;
	else mm_idxopt_init(&r->opt);
	if (r->is_idx) {
		r->fp.idx = fopen(fn, "rb");
		r->idx_size = is_idx;
	} else r->fp.seq = mm_bseq_open(fn);
	if (fn_out) r->fp_out = fopen(fn_out, "wb");
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
callq 0x868e
testq %rax, %rax
js 0x8770
movq %rax, %r12
movl $0x1, %edi
movl $0x38, %esi
callq 0x2230
movq %rax, %r14
movl %r12d, (%rax)
movq %rax, %rdi
addq $0x10, %rdi
testq %r13, %r13
je 0x8775
movq 0x10(%r13), %rax
movq %rax, 0x10(%rdi)
movups (%r13), %xmm0
movups %xmm0, (%rdi)
movl %r12d, %eax
jmp 0x877d
xorl %r14d, %r14d
jmp 0x87ba
callq 0x5fd8
movl (%r14), %eax
testl %eax, %eax
je 0x8796
leaq 0x24ba8(%rip), %rsi     # 0x2d330
movq %r15, %rdi
callq 0x2390
movq %r12, 0x8(%r14)
jmp 0x879e
movq %r15, %rdi
callq 0x12ff7
movq %rax, 0x30(%r14)
testq %rbx, %rbx
je 0x87ba
leaq 0x22bff(%rip), %rsi     # 0x2b3ad
movq %rbx, %rdi
callq 0x2390
movq %rax, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_reader_close
void mm_idx_reader_close(mm_idx_reader_t *r)
{
	if (r->is_idx) fclose(r->fp.idx);
	else mm_bseq_close(r->fp.seq);
	if (r->fp_out) fclose(r->fp_out);
	free(r);
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
movq 0x30(%rdi), %rdi
je 0x884d
callq 0x7fa7
movq %rax, %r14
testq %rax, %rax
je 0x8874
leaq 0x2dee5(%rip), %rax     # 0x36700
cmpl $0x2, (%rax)
jl 0x8874
movswl 0x10(%rbx), %eax
cmpl %eax, 0x8(%r14)
jne 0x8846
movswl 0x12(%rbx), %eax
cmpl %eax, 0x4(%r14)
jne 0x8846
movl 0xc(%r14), %eax
andl $0x1, %eax
movzwl 0x14(%rbx), %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0x8879
callq 0x2e9b
jmp 0x8879
movl %esi, %eax
movswl 0x12(%rbx), %esi
movswl 0x10(%rbx), %edx
movswl 0x16(%rbx), %ecx
movswl 0x14(%rbx), %r8d
movl 0x18(%rbx), %r9d
pushq 0x20(%rbx)
pushq %rax
callq 0x748c
addq $0x10, %rsp
movq %rax, %r14
testq %r14, %r14
je 0x8899
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x888a
movq %r14, %rsi
callq 0x7d64
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
movl %eax, 0x14(%r14)
jmp 0x889c
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_alt_read
int mm_idx_alt_read(mm_idx_t *mi, const char *fn)
{
	int n_alt = 0;
	gzFile fp;
	kstream_t *ks;
	kstring_t str = {0,0,0};
	fp = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) return -1;
	ks = ks_init(fp);
	if (mi->h == 0) mm_idx_index_name(mi);
	while (ks_getuntil(ks, KS_SEP_LINE, &str, 0) >= 0) {
		char *p;
		int id;
		for (p = str.s; *p && !isspace(*p); ++p) { }
		*p = 0;
		id = mm_idx_name2id(mi, str.s);
		if (id >= 0) mi->seq[id].is_alt = 1, ++n_alt;
	}
	mi->n_alt = n_alt;
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s] found %d ALT contigs\n", __func__, n_alt);
	return n_alt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rsi, %rsi
je 0x8926
cmpb $0x2d, (%rsi)
jne 0x8912
cmpb $0x0, 0x1(%rsi)
je 0x8926
leaq 0x24362(%rip), %rax     # 0x2cc7b
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2350
jmp 0x8943
movq 0x2d6ab(%rip), %rax     # 0x35fd8
movq (%rax), %rdi
callq 0x22b0
leaq 0x2433f(%rip), %rsi     # 0x2cc7b
movl %eax, %edi
callq 0x20f0
testq %rax, %rax
je 0x8a2d
movq %rax, %rdi
callq 0x12908
movq %rax, %r15
cmpq $0x0, 0x58(%rbx)
jne 0x8966
movq %rbx, %rdi
callq 0x6dec
xorl %r14d, %r14d
movq %rsp, %rdx
movq %r15, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12961
testl %eax, %eax
js 0x89f9
xorl %r14d, %r14d
movq %rsp, %r12
movq 0x10(%rsp), %r13
movb (%r13), %bpl
testb %bpl, %bpl
je 0x89b5
callq 0x2460
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x89b5
movb 0x1(%r13), %bpl
incq %r13
testb %bpl, %bpl
jne 0x899e
movb $0x0, (%r13)
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x70b7
testl %eax, %eax
js 0x89e0
movq 0x20(%rbx), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl $0x1, 0x14(%rcx,%rax,8)
incl %r14d
movq %r15, %rdi
movl $0x2, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12961
testl %eax, %eax
jns 0x8988
movl %r14d, 0x18(%rbx)
leaq 0x2dcfc(%rip), %rax     # 0x36700
cmpl $0x3, (%rax)
jl 0x8a33
movq 0x2d5e8(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x24987(%rip), %rsi     # 0x2d3a1
leaq 0x2499e(%rip), %rdx     # 0x2d3bf
movl %r14d, %ecx
xorl %eax, %eax
callq 0x2260
jmp 0x8a33
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_bed_junc
int mm_idx_bed_junc(const mm_idx_t *mi, int32_t ctg, int32_t st, int32_t en, uint8_t *s)
{
	int32_t i, left, right;
	mm_idx_intv_t *r;
	memset(s, 0, en - st);
	if (mi->I == 0 || ctg < 0 || ctg >= mi->n_seq) return -1;
	r = &mi->I[ctg];
	left = 0, right = r->n;
	while (right > left) {
		int32_t mid = left + ((right - left) >> 1);
		if (r->a[mid].st >= st) right = mid;
		else left = mid + 1;
	}
	for (i = left; i < r->n; ++i) {
		if (st <= r->a[i].st && en >= r->a[i].en && r->a[i].strand != 0) {
			if (r->a[i].strand > 0) {
				s[r->a[i].st - st] |= 1, s[r->a[i].en - 1 - st] |= 2;
			} else {
				s[r->a[i].st - st] |= 8, s[r->a[i].en - 1 - st] |= 4;
			}
		}
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl %ecx, %eax
subl %edx, %eax
movslq %eax, %rdx
movq %r8, %rdi
xorl %esi, %esi
callq 0x21b0
movq 0x38(%r12), %rdx
testq %rdx, %rdx
sete %al
testl %r15d, %r15d
sets %cl
orb %al, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x96dc
cmpl %r15d, 0x10(%r12)
jbe 0x96dc
movl %r15d, %eax
shlq $0x4, %rax
leaq (%rdx,%rax), %rcx
movl (%rdx,%rax), %edx
testl %edx, %edx
jle 0x9664
movq 0x8(%rcx), %rsi
xorl %eax, %eax
movl %edx, %edi
movl %edi, %r8d
subl %eax, %r8d
sarl %r8d
leal (%r8,%rax), %r9d
movslq %r9d, %r10
shlq $0x4, %r10
cmpl %r14d, (%rsi,%r10)
jl 0x9659
movl %r9d, %edi
jmp 0x965e
addl %r8d, %eax
incl %eax
cmpl %eax, %edi
jg 0x963a
jmp 0x9666
xorl %eax, %eax
cmpl %edx, %eax
jge 0x96dc
movl %r14d, %edx
notl %edx
movslq %eax, %rsi
movq %rsi, %rdi
shlq $0x4, %rdi
movl $0x1, %r8d
movq 0x8(%rcx), %r10
movl (%r10,%rdi), %r9d
subl %r14d, %r9d
jl 0x96cd
cmpl %ebp, 0x4(%r10,%rdi)
jg 0x96cd
cmpl $0x40000000, 0xc(%r10,%rdi) # imm = 0x40000000
jb 0x96cd
setl %r10b
movslq %r9d, %r9
movl $0x8, %r11d
cmovgel %r8d, %r11d
addb %r10b, %r10b
orb %r11b, (%rbx,%r9)
addb $0x2, %r10b
movq 0x8(%rcx), %r9
movl 0x4(%r9,%rdi), %r9d
addl %edx, %r9d
movslq %r9d, %r9
orb %r10b, (%rbx,%r9)
incq %rsi
movslq (%rcx), %r9
addq $0x10, %rdi
cmpq %r9, %rsi
jl 0x967f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: sort_jjump
static void sort_jjump(mm_idx_jjump_t *jj2)
{
	int32_t j0, j, k;
	if (jj2 == 0 || jj2->n == 0) return;
	radix_sort_jj(jj2->a, jj2->a + jj2->n);
	for (j0 = 0, j = 1; j <= jj2->n; ++j) {
		if (j == jj2->n || jj2->a[j0].off != jj2->a[j].off) {
			radix_sort_jj2(jj2->a + j0, jj2->a + j);
			j0 = j;
		}
	}
	// the actual merge
	for (j0 = 0, j = 1, k = 0; j <= jj2->n; ++j) {
		if (j == jj2->n || jj2->a[j0].off != jj2->a[j].off || jj2->a[j0].off2 != jj2->a[j].off2) {
			int32_t t, cnt = 0;
			uint16_t flag = 0;
			for (t = j0; t < j; ++t) cnt += jj2->a[t].cnt, flag |= jj2->a[t].flag;
			jj2->a[k] = jj2->a[j0];
			jj2->a[k].cnt = cnt;
			jj2->a[k++].flag = flag;
			j0 = j;
		}
	}
	jj2->n = k;
	jj2->a = REALLOC(mm_idx_jjump1_t, jj2->a, k);
}

// Assembly:
testq %rdi, %rdi
je 0xacd3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rsi
testq %rsi, %rsi
je 0xacce
movq 0x8(%rbx), %rdi
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x9966
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0xacb6
xorl %eax, %eax
movl $0x1, %r15d
movl $0x10, %r14d
movl %ecx, %edx
movq 0x8(%rbx), %rsi
movslq %eax, %rdi
cmpq %rdx, %r15
je 0xabcd
movq %rdi, %rdx
shlq $0x4, %rdx
movl (%rsi,%rdx), %edx
cmpl (%rsi,%r14), %edx
je 0xabe1
shlq $0x4, %rdi
addq %rsi, %rdi
addq %r14, %rsi
callq 0x9bdd
movl (%rbx), %ecx
movl %r15d, %eax
leaq 0x1(%r15), %rdx
movslq %ecx, %rsi
addq $0x10, %r14
cmpq %rsi, %r15
movq %rdx, %r15
jl 0xabaf
testl %ecx, %ecx
jle 0xacb6
movq 0x8(%rbx), %rdi
xorl %eax, %eax
movl $0x1, %edx
xorl %r8d, %r8d
movl %ecx, %r9d
movslq %r8d, %rsi
cmpq %r9, %rdx
je 0xac3d
movq %rsi, %r9
shlq $0x4, %r9
movl (%rdi,%r9), %r11d
movq %rdx, %r10
shlq $0x4, %r10
cmpl (%rdi,%r10), %r11d
jne 0xac3d
addq %rdi, %r9
addq %rdi, %r10
movl 0x4(%r9), %r9d
cmpl 0x4(%r10), %r9d
je 0xaca1
xorl %r8d, %r8d
movl $0x0, %ecx
cmpq %rsi, %rdx
jle 0xac75
movq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rdi,%rcx), %r9
addq $0xe, %r9
xorl %ecx, %ecx
movq %rsi, %r10
xorl %r8d, %r8d
addl -0x6(%r9), %r8d
orw (%r9), %cx
incq %r10
addq $0x10, %r9
cmpq %r10, %rdx
jne 0xac61
cltq
movq %rax, %r9
shlq $0x4, %r9
shlq $0x4, %rsi
movups (%rdi,%rsi), %xmm0
movups %xmm0, (%rdi,%r9)
movq 0x8(%rbx), %rdi
movl %r8d, 0x8(%rdi,%r9)
incl %eax
movw %cx, 0xe(%rdi,%r9)
movl (%rbx), %ecx
movl %edx, %r8d
leaq 0x1(%rdx), %rsi
movslq %ecx, %r9
cmpq %r9, %rdx
movq %rsi, %rdx
jl 0xac0a
jmp 0xacbc
movq 0x8(%rbx), %rdi
xorl %eax, %eax
movl %eax, (%rbx)
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x2320
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_jump_get
const mm_idx_jjump1_t *mm_idx_jump_get(const mm_idx_t *db, int32_t cid, int32_t st, int32_t en, int32_t *n)
{
	mm_idx_jjump_t *s;
	int32_t l, r;
	*n = 0;
	if (cid >= db->n_seq || cid < 0 || db->J == 0) return 0;
	if (en < 0 || en > db->seq[cid].len) en = db->seq[cid].len;
	s = &db->J[cid];
	if (s->n == 0) return 0;
	l = mm_idx_jump_get_core(s->n, s->a, st);
	r = mm_idx_jump_get_core(s->n, s->a, en);
	*n = r - l;
	return &s->a[l + 1];
}

// Assembly:
movl $0x0, (%r8)
xorl %eax, %eax
testl %esi, %esi
js 0x9fd6
cmpl %esi, 0x10(%rdi)
jbe 0x9fd6
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x9fca
movq %r8, %rbx
movl %esi, %esi
movq %rsi, %r8
shlq $0x4, %r8
movl (%r15,%r8), %eax
testl %eax, %eax
je 0x9fca
addq %r8, %r15
movq 0x20(%rdi), %rdi
leaq (%rsi,%rsi,2), %rsi
movl 0x10(%rdi,%rsi,8), %esi
cmpl %ecx, %esi
movl %ecx, %ebp
cmovbl %esi, %ebp
testl %ecx, %ecx
cmovsl %esi, %ebp
movq 0x8(%r15), %rsi
movl %eax, %edi
callq 0x9fd7
movl %eax, %r14d
movl (%r15), %edi
movq 0x8(%r15), %rsi
movl %ebp, %edx
callq 0x9fd7
subl %r14d, %eax
movl %eax, (%rbx)
movq 0x8(%r15), %rax
movslq %r14d, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x10, %rax
jmp 0x9fcc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_jump_get_core
static int32_t mm_idx_jump_get_core(int32_t n, const mm_idx_jjump1_t *a, int32_t x) // similar to mm_idx_find_intv()
{
	int32_t s = 0, e = n;
	if (n == 0) return -1;
	if (x < a[0].off) return -1;
	while (s < e) {
		int32_t mid = s + (e - s) / 2;
		if (x >= a[mid].off && (mid + 1 >= n || x < a[mid+1].off)) return mid;
		else if (x < a[mid].off) e = mid;
		else s = mid + 1;
	}
	assert(0);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %edi, %edi
je 0x9fe4
cmpl %edx, (%rsi)
jle 0x9fe5
retq
testl %edi, %edi
jle 0xa02c
xorl %ecx, %ecx
movl %edi, %r8d
movl %r8d, %r9d
subl %ecx, %r9d
movl %r9d, %eax
shrl $0x1f, %eax
addl %r9d, %eax
sarl %eax
addl %ecx, %eax
movslq %eax, %r9
shlq $0x4, %r9
cmpl %edx, (%rsi,%r9)
jle 0xa013
movl %eax, %r8d
jmp 0xa027
leal 0x1(%rax), %ecx
cmpl %edi, %ecx
jge 0x9fe4
movslq %ecx, %r9
shlq $0x4, %r9
cmpl %edx, (%rsi,%r9)
jg 0x9fe4
cmpl %r8d, %ecx
jl 0x9fee
pushq %rax
leaq 0x23a8d(%rip), %rdi     # 0x2dac1
leaq 0x2327e(%rip), %rsi     # 0x2d2b9
leaq 0x236b0(%rip), %rcx     # 0x2d6f2
movl $0x3af, %edx            # imm = 0x3AF
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_spsc_get
int64_t mm_idx_spsc_get(const mm_idx_t *db, int32_t cid, int64_t st, int64_t en, int32_t rev, uint8_t *sc)
{
	const mm_idx_spsc_t *s;
	if (cid >= db->n_seq || cid < 0 || db->spsc == 0) return -1;
	if (en < 0 || en > db->seq[cid].len) en = db->seq[cid].len;
	memset(sc, 0xff, en - st);
	s = &db->spsc[cid << 1 | (!!rev)];
	if (s->n > 0) {
		int32_t j, l, r;
		l = mm_idx_find_intv(s->n, s->a, st);
		r = mm_idx_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, %r15
testl %esi, %esi
js 0xa54a
movl %esi, %r13d
movq %rdi, %rbp
cmpl %esi, 0x10(%rdi)
jbe 0xa54a
cmpq $0x0, 0x40(%rbp)
je 0xa54a
movq %r9, %rbx
movq %rdx, %r14
movq 0x20(%rbp), %rax
movl %r13d, %edx
leaq (%rdx,%rdx,2), %rdx
movl 0x10(%rax,%rdx,8), %eax
cmpq %rcx, %rax
movq %rcx, %r12
cmovbq %rax, %r12
testq %rcx, %rcx
cmovsq %rax, %r12
movq %r12, %r15
subq %r14, %r15
movq %r9, %rdi
movl $0xff, %esi
movq %r15, %rdx
movl %r8d, 0x4(%rsp)
callq 0x21b0
movq 0x40(%rbp), %rbp
xorl %eax, %eax
cmpl $0x0, 0x4(%rsp)
setne %al
leal (%rax,%r13,2), %eax
cltq
shlq $0x4, %rax
movl (%rbp,%rax), %edi
testl %edi, %edi
je 0xa54a
addq %rax, %rbp
movq 0x8(%rbp), %rsi
movq %r14, %rdx
callq 0xa57b
movl %eax, %r13d
movl (%rbp), %edi
movq 0x8(%rbp), %rsi
movq %r12, %rdx
callq 0xa57b
cmpl %eax, %r13d
jge 0xa54a
movslq %r13d, %rcx
cltq
movl $0xff, %edx
movq 0x8(%rbp), %rsi
movq 0x8(%rsi,%rcx,8), %rsi
movq %rsi, %r8
shrq $0x8, %r8
movq %r8, %rdi
subq %r14, %rdi
cmpq %r15, %rdi
jg 0xa55c
cmpq %r12, %r8
je 0xa542
movzbl (%rbx,%rdi), %r8d
cmpl %edx, %r8d
setne %r9b
movl %esi, %r10d
andl %edx, %r10d
cmpl %r8d, %r10d
setbe %r8b
testb %r8b, %r9b
jne 0xa542
movb %sil, (%rbx,%rdi)
incq %rcx
cmpq %rcx, %rax
jne 0xa500
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22ff7(%rip), %rdi     # 0x2d55a
leaq 0x22d4f(%rip), %rsi     # 0x2d2b9
leaq 0x22ff6(%rip), %rcx     # 0x2d567
movl $0x42c, %edx            # imm = 0x42C
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap2/index.c
// Function: mm_idx_find_intv
static int32_t mm_idx_find_intv(int32_t n, const uint64_t *a, int64_t x)
{
	int32_t s = 0, e = n;
	if (n == 0) return -1;
	if (x < a[0]>>8) return -1;
	while (s < e) {
		int32_t mid = s + (e - s) / 2;
		if (x >= a[mid]>>8 && (mid + 1 >= n || x < a[mid+1]>>8)) return mid;
		else if (x < a[mid]>>8) e = mid;
		else s = mid + 1;
	}
	assert(0);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %edi, %edi
je 0xa590
movq (%rsi), %rcx
shrq $0x8, %rcx
cmpq %rdx, %rcx
jbe 0xa591
retq
testl %edi, %edi
jle 0xa5de
xorl %ecx, %ecx
movl %edi, %r8d
movl %r8d, %r9d
subl %ecx, %r9d
movl %r9d, %eax
shrl $0x1f, %eax
addl %r9d, %eax
sarl %eax
addl %ecx, %eax
movslq %eax, %r9
movq (%rsi,%r9,8), %r9
shrq $0x8, %r9
cmpq %rdx, %r9
jbe 0xa5c2
movl %eax, %r8d
jmp 0xa5d9
leal 0x1(%rax), %ecx
cmpl %edi, %ecx
jge 0xa590
movslq %ecx, %r9
movq (%rsi,%r9,8), %r9
shrq $0x8, %r9
cmpq %rdx, %r9
ja 0xa590
cmpl %r8d, %ecx
jl 0xa59a
pushq %rax
leaq 0x234db(%rip), %rdi     # 0x2dac1
leaq 0x22ccc(%rip), %rsi     # 0x2d2b9
leaq 0x23146(%rip), %rcx     # 0x2d73a
movl $0x41b, %edx            # imm = 0x41B
callq 0x21a0