LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test-vcf-api.c
// Function: check_format_values
void check_format_values(const char *fname)
{
    htsFile *fp = hts_open(fname, "r");
    bcf_hdr_t *hdr = bcf_hdr_read(fp);
    bcf1_t *line = bcf_init();

    while (bcf_read(fp, hdr, line) == 0)
    {
        float *values = 0;
        int count = 0;
        int ret = bcf_get_format_float(hdr, line, "TF", &values, &count);

        // NOTE the return value from bcf_get_format_float is different from
        // bcf_get_info_float in the sense that vector-end markers also count.
        if (ret != 4 ||
            count < ret ||
            !bcf_float_is_missing(values[0]) ||
            values[1] != 47.11f ||
            !bcf_float_is_vector_end(values[2]) ||
            !bcf_float_is_vector_end(values[3]))
        {
            fprintf(stderr, "bcf_get_format_float didn't produce the expected output.\n");
            exit(-1);
        }

        free(values);
    }

    bcf_destroy(line);
    bcf_hdr_destroy(hdr);
    hts_close(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x81a14(%rip), %rsi     # 0x8950f
callq 0xa70f
movq %rax, %rbx
movq %rax, %rdi
callq 0x27ba6
movq %rax, %r14
callq 0x2849e
movq %rax, %r15
pushq $0x2
popq %r12
leaq 0xac9af(%rip), %r13     # 0xb44d0
leaq 0xac9ac(%rip), %rbp     # 0xb44d4
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x288ae
testl %eax, %eax
jne 0x7ba1
andq $0x0, 0x10(%rsp)
andl $0x0, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq 0x7e124(%rip), %rdx     # 0x85c76
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl %r12d, %r9d
callq 0x328e0
cmpl $0x4, %eax
jne 0x7bc8
cmpl $0x4, 0xc(%rsp)
jl 0x7bc8
movq 0x10(%rsp), %rdi
movl (%r13), %eax
cmpl (%rdi), %eax
jne 0x7bc8
movss 0x4(%rdi), %xmm0
ucomiss 0x7c4bf(%rip), %xmm0    # 0x84048
jne 0x7bc8
jp 0x7bc8
movl 0x8(%rdi), %eax
cmpl %eax, (%rbp)
jne 0x7bc8
cmpl 0xc(%rdi), %eax
jne 0x7bc8
callq 0x45c0
jmp 0x7b28
movq %r15, %rdi
callq 0x28630
movq %r14, %rdi
callq 0x27a34
movq %rbx, %rdi
callq 0xb8e5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xab411(%rip), %rax     # 0xb2fe0
movq (%rax), %rcx
leaq 0x7e0d3(%rip), %rdi     # 0x85cac
pushq $0x39
popq %rsi
pushq $0x1
popq %rdx
callq 0x49b0
pushq $-0x1
popq %rdi
callq 0x45f0
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test-vcf-api.c
// Function: test_open_format
void test_open_format(void) {
    char mode[5];
    int ret;
    strcpy(mode, "r");
    ret = vcf_open_mode(mode+1, "mode1.bcf", NULL);
    if (strncmp(mode, "rb", 2) || ret)
        error("Mode '%s' does not match the expected value '%s'", mode, "rb");
    mode[1] = 0;
    ret = vcf_open_mode(mode+1, "mode1.vcf", NULL);
    if (strncmp(mode, "r", 1) || ret)
        error("Mode '%s' does not match the expected value '%s'", mode, "r");
    mode[1] = 0;
    ret = vcf_open_mode(mode+1, "mode1.vcf.gz", NULL);
    if (strncmp(mode, "rz", 2) || ret)
        error("Mode '%s' does not match the expected value '%s'", mode, "rz");
    mode[1] = 0;
    ret = vcf_open_mode(mode+1, "mode1.vcf.bgz", NULL);
    if (strncmp(mode, "rz", 2) || ret)
        error("Mode '%s' does not match the expected value '%s'", mode, "rz");
    mode[1] = 0;
    ret = vcf_open_mode(mode+1, "mode1.xcf", NULL);
    if (!ret)
        error("Expected failure for wrong extension 'xcf'");
    mode[1] = 0;
    ret = vcf_open_mode(mode+1, "mode1.vcf.gbz", NULL);
    if (!ret)
        error("Expected failure for wrong extension 'vcf.gbz'");
    mode[1] = 0;
    ret = vcf_open_mode(mode+1, "mode1.bvcf.bgz", NULL);
    if (!ret)
        error("Expected failure for wrong extension 'vcf.bvcf.bgz'");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xb(%rsp), %rbx
movw $0x72, -0x1(%rbx)
leaq 0x7e084(%rip), %rsi     # 0x85e5b
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d4fd
cmpw $0x6272, -0x1(%rbx)     # imm = 0x6272
jne 0x7ec8
testl %eax, %eax
jne 0x7ec8
movb $0x0, 0xb(%rsp)
leaq 0x7e095(%rip), %rsi     # 0x85e96
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d4fd
cmpb $0x72, 0xa(%rsp)
jne 0x7ed8
testl %eax, %eax
jne 0x7ed8
movb $0x0, 0xb(%rsp)
leaq 0x7e076(%rip), %rsi     # 0x85ea0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d4fd
cmpw $0x7a72, 0xa(%rsp)      # imm = 0x7A72
jne 0x7eb8
testl %eax, %eax
jne 0x7eb8
movb $0x0, 0xb(%rsp)
leaq 0x7e063(%rip), %rsi     # 0x85eb0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d4fd
cmpw $0x7a72, 0xa(%rsp)      # imm = 0x7A72
jne 0x7eb8
testl %eax, %eax
jne 0x7eb8
movb $0x0, 0xb(%rsp)
leaq 0x7e04e(%rip), %rsi     # 0x85ebe
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d4fd
testl %eax, %eax
je 0x7ef2
movb $0x0, 0xb(%rsp)
leaq 0x7e069(%rip), %rsi     # 0x85ef3
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d4fd
testl %eax, %eax
je 0x7efb
movb $0x0, 0xb(%rsp)
leaq 0x7e08c(%rip), %rsi     # 0x85f30
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d4fd
testl %eax, %eax
je 0x7f04
addq $0x10, %rsp
popq %rbx
retq
leaq 0x7dfa6(%rip), %rdi     # 0x85e65
leaq 0x7dfe7(%rip), %rdx     # 0x85ead
jmp 0x7ee6
leaq 0x7df96(%rip), %rdi     # 0x85e65
leaq 0x7d825(%rip), %rdx     # 0x856fb
jmp 0x7ee6
leaq 0x7df86(%rip), %rdi     # 0x85e65
leaq 0x81629(%rip), %rdx     # 0x8950f
leaq 0xa(%rsp), %rsi
xorl %eax, %eax
callq 0x5abc
leaq 0x7dfcf(%rip), %rdi     # 0x85ec8
jmp 0x7f0b
leaq 0x7dfff(%rip), %rdi     # 0x85f01
jmp 0x7f0b
leaq 0x7e034(%rip), %rdi     # 0x85f3f
xorl %eax, %eax
callq 0x5abc
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test-vcf-api.c
// Function: main
int main(int argc, char **argv)
{
    char *fname = argc>1 ? argv[1] : "rmme.bcf";

    // format test. quiet unless there's a failure
    test_get_format_values(fname);

    // main test. writes to stdout
    write_bcf(fname);
    bcf_to_vcf(fname);
    iterator(fname);

    // additional tests. quiet unless there's a failure.
    test_get_info_values(fname);
    test_invalid_end_tag();
    test_open_format();
    test_rlen_values();
    return 0;
}

// Assembly:
pushq %rbx
cmpl $0x2, %edi
jl 0x8485
movq 0x8(%rsi), %rbx
jmp 0x848c
leaq 0x7ddea(%rip), %rbx     # 0x86276
movq %rbx, %rdi
callq 0x7bec
movq %rbx, %rdi
callq 0x5b72
movq %rbx, %rdi
callq 0x6d7f
movq %rbx, %rdi
callq 0x74fb
movq %rbx, %rdi
callq 0x763d
callq 0x7bfe
callq 0x7dc0
callq 0x7f12
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/KeccakP-1600-opt64.c
// Function: KeccakP1600_Initialize
void KeccakP1600_Initialize(void *state)
{
    memset(state, 0, 200);
#ifdef KeccakP1600_useLaneComplementing
    ((UINT64*)state)[ 1] = ~(UINT64)0;
    ((UINT64*)state)[ 2] = ~(UINT64)0;
    ((UINT64*)state)[ 8] = ~(UINT64)0;
    ((UINT64*)state)[12] = ~(UINT64)0;
    ((UINT64*)state)[17] = ~(UINT64)0;
    ((UINT64*)state)[20] = ~(UINT64)0;
#endif
}

// Assembly:
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, 0x40(%rdi)
vmovdqu %ymm0, 0x60(%rdi)
vmovdqu %ymm0, 0x80(%rdi)
vmovdqu %ymm0, 0xa0(%rdi)
vmovdqu %ymm0, (%rdi)
vmovdqu %ymm0, 0x20(%rdi)
andq $0x0, 0xc0(%rdi)
orq $-0x1, 0x40(%rdi)
orq $-0x1, 0x60(%rdi)
orq $-0x1, 0x88(%rdi)
orq $-0x1, 0xa0(%rdi)
vpcmpeqd %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, 0x8(%rdi)
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/KeccakP-1600-opt64.c
// Function: KeccakP1600_AddBytesInLane
void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    UINT64 lane;
    if (length == 0)
        return;
    if (length == 1)
        lane = data[0];
    else {
        lane = 0;
        memcpy(&lane, data, length);
    }
    lane <<= offset*8;
#else
    UINT64 lane = 0;
    unsigned int i;
    for(i=0; i<length; i++)
        lane |= ((UINT64)data[i]) << ((i+offset)*8);
#endif
    ((UINT64*)state)[lanePosition] ^= lane;
}

// Assembly:
testl %r8d, %r8d
je 0x5895
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x1, %r8d
jne 0x5861
movzbl (%rdx), %eax
jmp 0x587c
movq %rsp, %r15
andq $0x0, (%r15)
movl %r8d, %eax
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x56b0
movq (%r15), %rax
shll $0x3, %r14d
shlxq %r14, %rax, %rax
movl %ebp, %ecx
xorq %rax, (%rbx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5a2a
movl $0x121106, %eax         # imm = 0x121106
btl %esi, %eax
jae 0x5a2a
movl %r8d, %eax
leal (%rcx,%rsi,8), %ecx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x5a29
movb (%rdx,%rsi), %r8b
notb %r8b
leal (%rcx,%rsi), %r9d
movb %r8b, (%rdi,%r9)
incq %rsi
jmp 0x5a10
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 0x56b0
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edx, %eax
xorl %ecx, %ecx
movl $0x121106, %edx         # imm = 0x121106
cmpq %rcx, %rax
je 0x5a74
cmpl $0x14, %ecx
ja 0x5a6e
btl %ecx, %edx
jae 0x5a6e
movq (%rsi,%rcx,8), %r8
notq %r8
movq %r8, (%rdi,%rcx,8)
incq %rcx
jmp 0x5a4f
movq (%rsi,%rcx,8), %r8
jmp 0x5a65
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
pushq $-0x1
popq %rdx
movl $0x120006, %r8d         # imm = 0x120006
cmpq %rcx, %rax
je 0x5b54
movl %ecx, %r10d
andl $0x7ffffffb, %r10d      # imm = 0x7FFFFFFB
movq %rdx, %r9
cmpl $0x8, %r10d
je 0x5b46
cmpl $0x14, %ecx
ja 0x5b4f
btl %ecx, %r8d
movq %rdx, %r9
jae 0x5b4f
movq %r9, (%rdi,%rcx,8)
incq %rcx
jmp 0x5b20
xorl %r9d, %r9d
jmp 0x5b46
movl %esi, %ecx
andl $0x7, %ecx
je 0x5b86
movl %esi, %edx
andl $-0x28, %edx
cmpl $0x40, %edx
je 0x5b74
cmpl $0x14, %eax
ja 0x5b87
movl $0x120006, %edx         # imm = 0x120006
btl %eax, %edx
jae 0x5b87
andl $-0x8, %esi
addq %rsi, %rdi
movl %ecx, %edx
movl $0xff, %esi
jmp 0x5070
retq
andl $-0x8, %esi
addq %rsi, %rdi
movl %ecx, %edx
xorl %esi, %esi
jmp 0x5070
// File: /workspace/github_c_makefile_star2_O2/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 0x56b0
cmpl $0x2, %r14d
jb 0xd372
notq 0x8(%rbx)
je 0xd372
notq 0x10(%rbx)
cmpl $0x9, %r14d
jb 0xd372
notq 0x40(%rbx)
cmpl $0xd, %r14d
jb 0xd372
notq 0x60(%rbx)
cmpl $0x12, %r14d
jb 0xd372
notq 0x88(%rbx)
cmpl $0x15, %r14d
jb 0xd372
notq 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    OceanKeyak_Instance instance;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp            # imm = 0x358
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, 0x18(%rsp)
movq %rdi, %rbp
movq 0x3a0(%rsp), %rsi
movq 0x398(%rsp), %rcx
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
leaq 0x20(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movl $0x96, %r8d
xorl %r9d, %r9d
callq 0x54e0
leaq (%rbx,%rbp), %rax
movq %rax, (%rsp)
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x53f0
addq $0x10, %rbx
movq 0x18(%rsp), %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x358, %rsp            # imm = 0x358
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/oceankeyakv2/generic64lc/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    OceanKeyak_Instance instance;
    unsigned long long mlen_;

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

// Assembly:
cmpq $0x10, %r8
jae 0x20d9c
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp            # imm = 0x358
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movq %rsi, %rbp
movq %rdi, %r15
movq 0x3a0(%rsp), %rsi
movq 0x398(%rsp), %rcx
andl $0x0, 0x10(%rsp)
andq $0x0, (%rsp)
pushq $0x1
popq %r12
movl %r12d, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
movl $0x96, %r8d
xorl %r9d, %r9d
callq 0x54e0
leaq -0x10(%r13), %rcx
movq %rcx, (%rbp)
leaq (%r14,%r13), %rax
addq $-0x10, %rax
movl %r12d, 0x8(%rsp)
movq %rax, (%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %r8
movq 0x390(%rsp), %r9
callq 0x53f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %r12d, %ecx
setne %al
negl %eax
addq $0x358, %rsp            # imm = 0x358
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1651
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %ecx, %eax
leaq 0x1ab9(%rip), %rcx      # 0x3018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq %ebp, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x1090
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
pushq $0x8
popq %rax
subl %ebp, %eax
movslq %eax, %rdx
jmp 0x1622
movslq %ebp, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x1090
addq %rsp, %r14
addq $0x8, %r14
pushq $0x8
popq %rax
subl %ebp, %eax
movslq %eax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1030
cmpl $0x7, %ebp
jg 0x1629
movb $-0x80, (%r14)
jmp 0x1629
leaq 0x9(%rsp), %rdi
movb $-0x34, -0x1(%rdi)
movslq %ebp, %r14
movq %r14, %rdx
callq 0x1090
leaq (%rsp,%r14), %rdi
addq $0x9, %rdi
pushq $0x7
popq %rax
subl %r14d, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
cmpl $0x6, %r14d
jg 0x1629
leaq 0x8(%rsp), %rax
movb $-0x80, 0x1(%r14,%rax)
jmp 0x1629
movslq %ebp, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
subq %rdx, %rdi
addq $0x8, %rdi
callq 0x1090
pushq $0x8
popq %rax
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 0x19d3(%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_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps 0x7ca(%rip), %xmm0      # 0x3310
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 0x2bd4
movl %eax, %r14d
movl $0x8000000, %esi        # imm = 0x8000000
movl %ebp, %edi
callq 0x2110
testl %eax, %eax
jne 0x2bed
movslq %r14d, %r12
movq %rsp, %rdi
callq 0x2080
pushq $0x3
popq %r14
pushq $0x2
popq %r15
movl $0x8000000, %esi        # imm = 0x8000000
xorl %edi, %edi
movl %r14d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x20e0
cmpq $-0x1, %rax
je 0x2c06
xorl %ecx, %ecx
cmpq $0x7ffffff, %rcx        # imm = 0x7FFFFFF
ja 0x2bc5
movb $0x0, (%rax,%rcx)
incq (%rbx)
addq %r12, %rcx
jmp 0x2bb0
movl $0x8000000, %esi        # imm = 0x8000000
movq %rax, %rdi
callq 0x21d0
jmp 0x2b90
leaq 0x6b6(%rip), %rdi       # 0x3291
leaq 0x6b7(%rip), %rsi       # 0x3299
leaq 0x6c4(%rip), %rcx       # 0x32ad
pushq $0x10
jmp 0x2c1d
leaq 0x6ec(%rip), %rdi       # 0x32e0
leaq 0x69e(%rip), %rsi       # 0x3299
leaq 0x6ab(%rip), %rcx       # 0x32ad
pushq $0x11
jmp 0x2c1d
leaq 0x6ef(%rip), %rdi       # 0x32fc
leaq 0x685(%rip), %rsi       # 0x3299
leaq 0x692(%rip), %rcx       # 0x32ad
pushq $0x19
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 0x2366f(%rip), %rsi     # 0x279bf
movq %rcx, %rdi
callq 0x2240
testl %r12d, %r12d
je 0x4371
testl %eax, %eax
je 0x43b7
movzbl (%r15), %eax
cmpl $0x6e, %eax
je 0x4385
cmpl $0x79, %eax
je 0x43b0
jmp 0x43c3
testl %eax, %eax
je 0x439a
movzbl (%r15), %eax
cmpl $0x6e, %eax
je 0x43a2
cmpl $0x79, %eax
je 0x4393
jmp 0x43c3
cmpb $0x6f, 0x1(%r15)
jne 0x4393
cmpb $0x0, 0x2(%r15)
je 0x439a
cmpb $0x0, 0x1(%r15)
jne 0x43c3
notq %rbx
andq %rbx, (%r14)
jmp 0x43ba
cmpb $0x6f, 0x1(%r15)
jne 0x43b0
cmpb $0x0, 0x2(%r15)
je 0x43b7
cmpb $0x0, 0x1(%r15)
jne 0x43c3
orq %rbx, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2dc2e(%rip), %rax     # 0x31ff8
movq (%rax), %rdi
movslq %ebp, %rax
shlq $0x4, %rax
leaq 0x2de75(%rip), %rcx     # 0x32250
movq (%rax,%rcx), %rdx
leaq 0x235dd(%rip), %rsi     # 0x279c3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2260
// File: /workspace/github_c_makefile_star2_O2/lh3[P]minimap2/misc.c
// Function: mm_err_puts
void mm_err_puts(const char *str)
{
	int ret;
	ret = puts(str);
	if (ret == EOF) {
		perror("[ERROR] failed to write the results");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rax
callq 0x20b0
cmpl $-0x1, %eax
je 0x455d
popq %rax
retq
leaq 0x23101(%rip), %rdi     # 0x27665
callq 0x23b0
pushq $0x1
popq %rdi
callq 0x23e0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]minimap2/misc.c
// Function: mm_err_fwrite
void mm_err_fwrite(const void *p, size_t size, size_t nitems, FILE *fp)
{
	int ret;
	ret = fwrite(p, size, nitems, fp);
	if (ret == EOF) {
		perror("[ERROR] failed to write data");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rax
callq 0x23f0
cmpl $-0x1, %eax
je 0x457e
popq %rax
retq
leaq 0x234ab(%rip), %rdi     # 0x27a30
callq 0x23b0
pushq $0x1
popq %rdi
callq 0x23e0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]minimap2/misc.c
// Function: mm_err_fread
void mm_err_fread(void *p, size_t size, size_t nitems, FILE *fp)
{
	int ret;
	ret = fread(p, size, nitems, fp);
	if (ret == EOF) {
		perror("[ERROR] failed to read data");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rax
callq 0x20c0
cmpl $-0x1, %eax
je 0x459f
popq %rax
retq
leaq 0x234a7(%rip), %rdi     # 0x27a4d
callq 0x23b0
pushq $0x1
popq %rdi
callq 0x23e0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
testw $0x300, %ax             # imm = 0x300
je 0x4dde
orq $0x80, %rax
movq %rax, (%rbx)
cmpl $0x0, 0xd4(%rbx)
jg 0x4e1a
movss 0xc4(%rbx), %xmm0
movq %rsi, %rdi
callq 0x6259
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 0x4e25
movl %eax, 0x18(%rbx)
leaq 0x2d8d4(%rip), %rax     # 0x32700
cmpl $0x3, (%rax)
jge 0x4e3b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x2d1b6(%rip), %rax     # 0x31ff8
movq (%rax), %r14
callq 0x4521
leaq 0x2dadf(%rip), %r15     # 0x32930
subsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x44b8
movsd %xmm0, (%rsp)
callq 0x4521
subsd (%r15), %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movl 0xd4(%rbx), %ecx
leaq 0x22d6e(%rip), %rsi     # 0x27bf4
leaq 0x22d88(%rip), %rdx     # 0x27c15
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2260
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r13
cmovll %r13d, %r15d
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
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
pushq $0x30
popq %rsi
callq 0x2230
movq %rax, 0x30(%rbx)
leaq 0x2cff7(%rip), %rax     # 0x32928
testb $0x1, (%rax)
jne 0x593f
callq 0x109c3
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_O2/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 0x5a87
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %r14
testq %r14, %r14
je 0x5996
movq 0x18(%r14), %rsi
xorl %edi, %edi
callq 0x10a07
movq 0x10(%r14), %rsi
xorl %edi, %edi
callq 0x10a07
movq 0x20(%r14), %rsi
xorl %edi, %edi
callq 0x10a07
xorl %edi, %edi
movq %r14, %rsi
callq 0x10a07
cmpq $0x0, 0x30(%rbx)
je 0x5a0c
xorl %r15d, %r15d
movb (%rbx), %cl
movl %r15d, %eax
shrl %cl, %eax
testl %eax, %eax
jne 0x5a0c
movq 0x30(%rbx), %rax
movl %r15d, %ecx
imulq $0x30, %rcx, %r14
movq 0x20(%rax,%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 0x5a07
movq 0x18(%r14), %rsi
xorl %edi, %edi
callq 0x10a07
movq 0x10(%r14), %rsi
xorl %edi, %edi
callq 0x10a07
movq 0x20(%r14), %rsi
xorl %edi, %edi
callq 0x10a07
xorl %edi, %edi
movq %r14, %rsi
callq 0x10a07
incl %r15d
jmp 0x59a0
movq 0x40(%rbx), %rdi
callq 0x2040
cmpq $0x0, 0x38(%rbx)
je 0x5a46
pushq $0x8
popq %r14
xorl %r15d, %r15d
movl 0x10(%rbx), %eax
movq 0x38(%rbx), %rdi
cmpq %rax, %r15
jae 0x5a41
movq (%rdi,%r14), %rdi
callq 0x2040
incq %r15
addq $0x10, %r14
jmp 0x5a23
callq 0x2040
cmpq $0x0, 0x48(%rbx)
je 0x5a77
pushq $0x8
popq %r14
xorl %r15d, %r15d
movl 0x10(%rbx), %eax
movq 0x48(%rbx), %rdi
cmpq %rax, %r15
jae 0x5a72
movq (%rdi,%r14), %rdi
callq 0x2040
incq %r15
addq $0x10, %r14
jmp 0x5a54
callq 0x2040
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x5a88
callq 0x109cc
jmp 0x5ab1
retq
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0x10(%rbx), %eax
movq 0x20(%rbx), %rdi
cmpq %rax, %r15
jae 0x5aac
movq (%rdi,%r14), %rdi
callq 0x2040
incq %r15
addq $0x18, %r14
jmp 0x5a8e
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_O2/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)
jne 0x5e26
movq %rdi, %r14
xorl %r13d, %r13d
callq 0x5e55
movq %rax, %r15
pushq $0x1
popq %rbp
xorl %r12d, %r12d
xorl %ebx, %ebx
movl 0x10(%r14), %eax
cmpq %rax, %r12
jae 0x5e12
movq 0x20(%r14), %rax
movq (%rax,%r13), %rsi
movq %r15, %rdi
leaq 0x4(%rsp), %rdx
callq 0x5e62
cmpl $0x0, 0x4(%rsp)
movl %ebp, %ecx
je 0x5e07
movq 0x20(%r15), %rcx
movl %eax, %eax
movl %r12d, (%rcx,%rax,4)
movl %ebx, %ecx
incq %r12
addq $0x18, %r13
movl %ecx, %ebx
jmp 0x5dd4
movq %r15, 0x58(%r14)
testl %ebx, %ebx
je 0x5e26
leaq 0x2c8df(%rip), %rax     # 0x32700
cmpl $0x2, (%rax)
jge 0x5e37
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2c1ba(%rip), %rax     # 0x31ff8
movq (%rax), %rcx
leaq 0x223cf(%rip), %rdi     # 0x28217
pushq $0x40
popq %rsi
pushq $0x1
popq %rdx
callq 0x23f0
jmp 0x5e26
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, 0x18(%rsp)
movq 0x58(%rdi), %r14
testq %r14, %r14
je 0x60ef
movl (%r14), %ecx
pushq $-0x1
popq %rax
testl %ecx, %ecx
je 0x6110
movq %rcx, 0x20(%rsp)
leal -0x1(%rcx), %ebx
movq 0x18(%rsp), %rdi
callq 0x9684
movl %eax, %ebp
movl %ebx, 0xc(%rsp)
andl %ebx, %ebp
movq %r14, 0x10(%rsp)
movq 0x10(%r14), %r14
pushq $0x1
popq %r12
movl %ebp, %ebx
movl %ebx, %eax
shrl $0x4, %eax
movl (%r14,%rax,4), %r13d
leal (%rbx,%rbx), %r15d
andl $0x1e, %r15d
movl %r13d, %eax
movl %r15d, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x60f4
testb $0x1, %al
jne 0x60dd
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x2240
testl %eax, %eax
je 0x60f4
addl %r12d, %ebx
andl 0xc(%rsp), %ebx
incl %r12d
cmpl %ebp, %ebx
jne 0x609f
pushq $-0x1
jmp 0x60f1
pushq $-0x2
popq %rax
jmp 0x611f
movl %r15d, %ecx
shrl %cl, %r13d
testb $0x3, %r13b
movq 0x20(%rsp), %rcx
cmovnel %ecx, %ebx
pushq $-0x1
popq %rax
movq 0x10(%rsp), %r14
jmp 0x6112
xorl %ebx, %ebx
cmpl %ecx, %ebx
je 0x611f
movq 0x20(%r14), %rax
movl %ebx, %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_O2/lh3[P]minimap2/index.c
// Function: mm_idx_getseq
int mm_idx_getseq(const mm_idx_t *mi, uint32_t rid, uint32_t st, uint32_t en, uint8_t *seq)
{
	uint64_t i, st1, en1;
	if (rid >= mi->n_seq || st >= mi->seq[rid].len) return -1;
	if (en > mi->seq[rid].len) en = mi->seq[rid].len;
	st1 = mi->seq[rid].offset + st;
	en1 = mi->seq[rid].offset + en;
	for (i = st1; i < en1; ++i)
		seq[i - st1] = mm_seq4_get(mi->S, i);
	return en - st;
}

// Assembly:
pushq $-0x1
popq %rax
cmpl %esi, 0x10(%rdi)
jbe 0x619b
movl %ecx, %r9d
movq 0x20(%rdi), %rcx
movl %esi, %esi
imulq $0x18, %rsi, %rsi
movl 0x10(%rcx,%rsi), %r10d
cmpl %edx, %r10d
jbe 0x619b
cmpl %r9d, %r10d
cmovbl %r10d, %r9d
movq 0x8(%rcx,%rsi), %rax
movl %edx, %esi
addq %rax, %rsi
leaq (%r9,%rax), %r10
addl %edx, %eax
shll $0x2, %eax
cmpq %r10, %rsi
jae 0x6195
movq 0x28(%rdi), %rcx
movq %rsi, %r11
shrq $0x3, %r11
movl (%rcx,%r11,4), %r11d
movl %eax, %ecx
andb $0x1c, %cl
shrl %cl, %r11d
andb $0xf, %r11b
movb %r11b, (%r8)
incq %rsi
addl $0x4, %eax
incq %r8
jmp 0x6167
subl %edx, %r9d
movl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6236
movl %ecx, %r9d
movq 0x20(%rdi), %r10
movl %esi, %ecx
imulq $0x18, %rcx, %rsi
movl 0x10(%r10,%rsi), %ecx
movl %ecx, %r11d
subl %edx, %r11d
jbe 0x6236
pushq %rbx
addq %rsi, %r10
cmpl %r9d, %ecx
cmovbl %ecx, %r9d
movq 0x8(%r10), %rax
movl %ecx, %ebx
subl %r9d, %ebx
leaq (%rax,%rbx), %rsi
leaq (%rax,%r11), %r10
notq %rbx
addq %r11, %r8
addq %rbx, %r8
addl %ecx, %eax
subl %r9d, %eax
shll $0x2, %eax
cmpq %r10, %rsi
jae 0x622f
movq 0x28(%rdi), %rcx
movq %rsi, %r11
shrq $0x3, %r11
movl (%rcx,%r11,4), %r11d
movl %eax, %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, (%r8)
incq %rsi
decq %r8
addl $0x4, %eax
jmp 0x61f1
subl %edx, %r9d
movl %r9d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6391
movq %rdi, %rbx
movb (%rdi), %cl
pushq $0x1
popq %r15
movl %r15d, %r12d
shll %cl, %r12d
cvtss2sd %xmm0, %xmm0
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
imulq $0x30, %r12, %rcx
xorl %edi, %edi
cmpq %rax, %rcx
je 0x62b7
movq 0x30(%rbx), %rdx
movq 0x28(%rdx,%rax), %rdx
testq %rdx, %rdx
je 0x62b1
movl 0x4(%rdx), %edx
addq %rdx, %rdi
addq $0x30, %rax
jmp 0x6298
testq %rdi, %rdi
je 0x6391
movsd %xmm0, 0x8(%rsp)
shlq $0x2, %rdi
callq 0x22f0
movq %rax, %r14
xorl %eax, %eax
xorl %edi, %edi
cmpq %r12, %rax
je 0x6343
movq 0x30(%rbx), %rcx
imulq $0x30, %rax, %rdx
movq 0x28(%rcx,%rdx), %rdx
testq %rdx, %rdx
je 0x633e
movl (%rdx), %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rsi, %r9
jae 0x633e
movq 0x10(%rdx), %rcx
movq %r9, %r10
shrq $0x4, %r10
movl (%rcx,%r10,4), %r10d
movl %r8d, %ecx
andb $0x1e, %cl
shrl %cl, %r10d
testb $0x3, %r10b
jne 0x6335
movq 0x18(%rdx), %rcx
testb $0x1, (%rcx,%r9,8)
movl %r15d, %ecx
jne 0x632e
movq 0x20(%rdx), %rcx
movl (%rcx,%r9,8), %ecx
movl %ecx, (%r14,%rdi,4)
incq %rdi
incq %r9
addl $0x2, %r8d
jmp 0x62f5
incq %rax
jmp 0x62d6
movsd 0x1fcc5(%rip), %xmm0    # 0x26010
movq %rdi, %xmm1
punpckldq 0x21d78(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x21d80(%rip), %xmm1    # 0x280e0
subsd 0x8(%rsp), %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 %r14, %rsi
callq 0x4a71
movl %eax, %ebp
incl %ebp
movq %r14, %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_O2/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 0x63d5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0x1197c
testl %eax, %eax
je 0x63d8
xorl %eax, %eax
jmp 0x6460
xorl %eax, %eax
retq
movq 0x78(%rsp), %rax
movl 0x70(%rsp), %r8d
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
andq $0x0, 0x10(%rdx)
movslq %ebx, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movapd %xmm0, (%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 0x58d0
movq %rax, 0x20(%rbx)
cmpl $0x3, %ebp
pushq $0x3
popq %rcx
movl %ecx, %edi
cmovll %ebp, %edi
leaq 0xfd(%rip), %rsi        # 0x6531
movq %rbx, %rdx
callq 0x10711
leaq 0x2c2bd(%rip), %r14     # 0x32700
cmpl $0x3, (%r14)
jge 0x646f
movq 0x30(%rsp), %rdi
movl %ebp, %esi
callq 0x6935
cmpl $0x3, (%r14)
jge 0x64d0
movq 0x30(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2bb82(%rip), %rax     # 0x31ff8
movq (%rax), %rbx
callq 0x4521
leaq 0x2c4ab(%rip), %r15     # 0x32930
subsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x44b8
movsd %xmm0, (%rsp)
callq 0x4521
subsd (%r15), %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
leaq 0x21da4(%rip), %rsi     # 0x28258
leaq 0x21dc6(%rip), %rdx     # 0x28281
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x2260
jmp 0x6449
movq 0x2bb21(%rip), %rax     # 0x31ff8
movq (%rax), %rbx
callq 0x4521
leaq 0x2c44a(%rip), %r14     # 0x32930
subsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x44b8
movsd %xmm0, (%rsp)
callq 0x4521
subsd (%r14), %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
leaq 0x21d77(%rip), %rsi     # 0x2828c
leaq 0x21d65(%rip), %rdx     # 0x28281
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x2260
jmp 0x645b
// File: /workspace/github_c_makefile_star2_O2/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 0x113b6
testq %rax, %rax
je 0x699f
movq %rax, %r14
pushq $0xe
popq %rcx
movq %rax, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %ebp, %r8d
movl $0x40000, %r9d          # imm = 0x40000
pushq $-0x1
pushq %rbx
callq 0x63a0
popq %rcx
popq %rdx
movq %rax, %rbx
movq %r14, %rdi
callq 0x1141b
movq %rbx, %rax
jmp 0x69a1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]minimap2/index.c
// Function: mm_idx_add
static void mm_idx_add(mm_idx_t *mi, int n, const mm128_t *a)
{
	int i, mask = (1<<mi->b) - 1;
	for (i = 0; i < n; ++i) {
		mm128_v *p = &mi->B[a[i].x>>8&mask].a;
		kv_push(mm128_t, 0, *p, a[i]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movb (%rdi), %cl
pushq $-0x1
popq %r12
shll %cl, %r12d
movl %esi, %r15d
notl %r12d
xorl %r13d, %r13d
testl %esi, %esi
cmovlel %r13d, %r15d
shlq $0x4, %r15
cmpq %r13, %r15
je 0x6ca8
movq 0x30(%r14), %rax
movl 0x1(%rbx,%r13), %ecx
andl %r12d, %ecx
imulq $0x30, %rcx, %rdx
leaq (%rax,%rdx), %rbp
movq (%rax,%rdx), %rcx
cmpq 0x8(%rax,%rdx), %rcx
jne 0x6c87
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
pushq $0x2
popq %rax
cmoveq %rax, %rdx
movq %rdx, 0x8(%rbp)
movq 0x10(%rbp), %rsi
shlq $0x4, %rdx
xorl %edi, %edi
callq 0x10c04
movq %rax, 0x10(%rbp)
movq (%rbp), %rcx
jmp 0x6c8b
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
jmp 0x6c38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x759a
testq %rax, %rax
js 0x7670
movq %rax, %r12
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x2230
movq %rax, %r14
movl %r12d, (%rax)
movq %rax, %rdi
addq $0x10, %rdi
testq %r13, %r13
je 0x7675
movq 0x10(%r13), %rax
movq %rax, 0x10(%rdi)
movups (%r13), %xmm0
movups %xmm0, (%rdi)
movl %r12d, %eax
jmp 0x767d
xorl %r14d, %r14d
jmp 0x76ba
callq 0x4c88
movl (%r14), %eax
testl %eax, %eax
je 0x7696
leaq 0x20ca8(%rip), %rsi     # 0x28330
movq %r15, %rdi
callq 0x2390
movq %r12, 0x8(%r14)
jmp 0x769e
movq %r15, %rdi
callq 0x113b6
movq %rax, 0x30(%r14)
testq %rbx, %rbx
je 0x76ba
leaq 0x1ecff(%rip), %rsi     # 0x263ad
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_O2/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 0x76db
callq 0x2120
jmp 0x76e0
callq 0x1141b
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x76ee
callq 0x2120
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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 0x7764
callq 0x6ef7
movq %rax, %r14
testq %rax, %rax
je 0x7789
leaq 0x2afe5(%rip), %rax     # 0x32700
cmpl $0x2, (%rax)
jl 0x7789
movswl 0x10(%rbx), %eax
cmpl %eax, 0x8(%r14)
jne 0x7746
movswl 0x12(%rbx), %eax
cmpl %eax, 0x4(%r14)
jne 0x7746
movl 0xc(%r14), %eax
andl $0x1, %eax
movzwl 0x14(%rbx), %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0x778e
movq 0x2a8ab(%rip), %rax     # 0x31ff8
movq (%rax), %rcx
leaq 0x20bdc(%rip), %rdi     # 0x28333
pushq $0x6d
popq %rsi
pushq $0x1
popq %rdx
callq 0x23f0
jmp 0x778e
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 0x63a0
popq %rcx
popq %rdx
movq %rax, %r14
testq %r14, %r14
je 0x77ae
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x779f
movq %r14, %rsi
callq 0x6cb7
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
movl %eax, 0x14(%r14)
jmp 0x77b1
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq