LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_db_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_striped_profile_16_pointer = parasail_sg_db_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_striped_profile_16_pointer = parasail_sg_db_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_striped_profile_16_pointer = parasail_sg_db_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_striped_profile_16_pointer = parasail_sg_db_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_striped_profile_16_pointer = parasail_sg_db_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22be66
leaq 0x296c69(%rip), %rax    # 0x4c2acd
jmp 0x22be8c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22be7a
leaq 0x1a7ade(%rip), %rax    # 0x3d3956
jmp 0x22be8c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22beab
leaq 0x984f8(%rip), %rax     # 0x2c4384
movq %rax, 0x5ae09d(%rip)    # 0x7d9f30
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_db_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_striped_profile_8_pointer = parasail_sg_db_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_striped_profile_8_pointer = parasail_sg_db_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_striped_profile_8_pointer = parasail_sg_db_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_striped_profile_8_pointer = parasail_sg_db_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_striped_profile_8_pointer = parasail_sg_db_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22bee0
leaq 0x299b18(%rip), %rax    # 0x4c59f6
jmp 0x22bf06
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22bef4
leaq 0x1a97d0(%rip), %rax    # 0x3d56c2
jmp 0x22bf06
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22bf25
leaq 0x9aa80(%rip), %rax     # 0x2c6986
movq %rax, 0x5ae02b(%rip)    # 0x7d9f38
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_db_stats_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_scan_profile_64_pointer = parasail_sg_db_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_profile_64_pointer = parasail_sg_db_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_profile_64_pointer = parasail_sg_db_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_profile_64_pointer = parasail_sg_db_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_profile_64_pointer = parasail_sg_db_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22bf5a
leaq 0x29c27e(%rip), %rax    # 0x4c81d6
jmp 0x22bf80
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22bf6e
leaq 0x1ac6e6(%rip), %rax    # 0x3d8652
jmp 0x22bf80
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22bf9f
leaq 0x9de33(%rip), %rax     # 0x2c9db3
movq %rax, 0x5adfb9(%rip)    # 0x7d9f40
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_db_stats_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_scan_profile_32_pointer = parasail_sg_db_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_profile_32_pointer = parasail_sg_db_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_profile_32_pointer = parasail_sg_db_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_profile_32_pointer = parasail_sg_db_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_profile_32_pointer = parasail_sg_db_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22bfd4
leaq 0x29f192(%rip), %rax    # 0x4cb164
jmp 0x22bffa
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22bfe8
leaq 0x1af71f(%rip), %rax    # 0x3db705
jmp 0x22bffa
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c019
leaq 0xa16e6(%rip), %rax     # 0x2cd6e0
movq %rax, 0x5adf47(%rip)    # 0x7d9f48
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_db_stats_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_scan_profile_16_pointer = parasail_sg_db_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_profile_16_pointer = parasail_sg_db_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_profile_16_pointer = parasail_sg_db_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_profile_16_pointer = parasail_sg_db_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_profile_16_pointer = parasail_sg_db_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c04e
leaq 0x2a28e4(%rip), %rax    # 0x4ce930
jmp 0x22c074
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c062
leaq 0x1b2af1(%rip), %rax    # 0x3deb51
jmp 0x22c074
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c093
leaq 0xa529e(%rip), %rax     # 0x2d1312
movq %rax, 0x5aded5(%rip)    # 0x7d9f50
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_db_stats_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_scan_profile_8_pointer = parasail_sg_db_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_profile_8_pointer = parasail_sg_db_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_profile_8_pointer = parasail_sg_db_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_profile_8_pointer = parasail_sg_db_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_profile_8_pointer = parasail_sg_db_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c0c8
leaq 0x2a6b64(%rip), %rax    # 0x4d2c2a
jmp 0x22c0ee
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c0dc
leaq 0x1b6300(%rip), %rax    # 0x3e23da
jmp 0x22c0ee
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c10d
leaq 0xa97a7(%rip), %rax     # 0x2d5895
movq %rax, 0x5ade63(%rip)    # 0x7d9f58
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_db_stats_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_striped_profile_64_pointer = parasail_sg_db_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_profile_64_pointer = parasail_sg_db_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_profile_64_pointer = parasail_sg_db_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_profile_64_pointer = parasail_sg_db_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_profile_64_pointer = parasail_sg_db_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c142
leaq 0x2b9b9a(%rip), %rax    # 0x4e5cda
jmp 0x22c168
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c156
leaq 0x1c72c3(%rip), %rax    # 0x3f3417
jmp 0x22c168
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c187
leaq 0xbd9e0(%rip), %rax     # 0x2e9b48
movq %rax, 0x5addf1(%rip)    # 0x7d9f60
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_db_stats_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_striped_profile_32_pointer = parasail_sg_db_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_profile_32_pointer = parasail_sg_db_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_profile_32_pointer = parasail_sg_db_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_profile_32_pointer = parasail_sg_db_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_profile_32_pointer = parasail_sg_db_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c1bc
leaq 0x2bc85c(%rip), %rax    # 0x4e8a16
jmp 0x22c1e2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c1d0
leaq 0x1ca0c9(%rip), %rax    # 0x3f6297
jmp 0x22c1e2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c201
leaq 0xc1325(%rip), %rax     # 0x2ed507
movq %rax, 0x5add7f(%rip)    # 0x7d9f68
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_db_stats_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_striped_profile_16_pointer = parasail_sg_db_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_profile_16_pointer = parasail_sg_db_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_profile_16_pointer = parasail_sg_db_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_profile_16_pointer = parasail_sg_db_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_profile_16_pointer = parasail_sg_db_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c236
leaq 0x2bff78(%rip), %rax    # 0x4ec1ac
jmp 0x22c25c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c24a
leaq 0x1cd260(%rip), %rax    # 0x3f94a8
jmp 0x22c25c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c27b
leaq 0xc49e0(%rip), %rax     # 0x2f0c3c
movq %rax, 0x5add0d(%rip)    # 0x7d9f70
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_db_stats_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_striped_profile_8_pointer = parasail_sg_db_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_profile_8_pointer = parasail_sg_db_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_profile_8_pointer = parasail_sg_db_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_profile_8_pointer = parasail_sg_db_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_profile_8_pointer = parasail_sg_db_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c2b0
leaq 0x2c4615(%rip), %rax    # 0x4f08c3
jmp 0x22c2d6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c2c4
leaq 0x1d07e4(%rip), %rax    # 0x3fcaa6
jmp 0x22c2d6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c2f5
leaq 0xc8a8c(%rip), %rax     # 0x2f4d62
movq %rax, 0x5adc9b(%rip)    # 0x7d9f78
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_db_table_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_scan_profile_64_pointer = parasail_sg_db_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_profile_64_pointer = parasail_sg_db_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_profile_64_pointer = parasail_sg_db_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_profile_64_pointer = parasail_sg_db_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_profile_64_pointer = parasail_sg_db_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c32a
leaq 0x2c7a1d(%rip), %rax    # 0x4f3d45
jmp 0x22c350
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c33e
leaq 0x1d29d5(%rip), %rax    # 0x3fed11
jmp 0x22c350
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c36f
leaq 0xcc54b(%rip), %rax     # 0x2f889b
movq %rax, 0x5adc29(%rip)    # 0x7d9f80
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_db_table_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_scan_profile_32_pointer = parasail_sg_db_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_profile_32_pointer = parasail_sg_db_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_profile_32_pointer = parasail_sg_db_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_profile_32_pointer = parasail_sg_db_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_profile_32_pointer = parasail_sg_db_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c3a4
leaq 0x2c9666(%rip), %rax    # 0x4f5a08
jmp 0x22c3ca
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c3b8
leaq 0x1d44f2(%rip), %rax    # 0x4008a8
jmp 0x22c3ca
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c3e9
leaq 0xce52d(%rip), %rax     # 0x2fa8f7
movq %rax, 0x5adbb7(%rip)    # 0x7d9f88
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_db_table_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c41e
leaq 0x2cc1cb(%rip), %rax    # 0x4f85e7
jmp 0x22c444
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c432
leaq 0x1d64bb(%rip), %rax    # 0x4028eb
jmp 0x22c444
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c463
leaq 0xd0945(%rip), %rax     # 0x2fcd89
movq %rax, 0x5adb45(%rip)    # 0x7d9f90
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_db_table_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c498
leaq 0x2cffed(%rip), %rax    # 0x4fc483
jmp 0x22c4be
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c4ac
leaq 0x1d8c3a(%rip), %rax    # 0x4050e4
jmp 0x22c4be
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c4dd
leaq 0xd3a16(%rip), %rax     # 0x2ffed4
movq %rax, 0x5adad3(%rip)    # 0x7d9f98
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c512
leaq 0x2df907(%rip), %rax    # 0x50be17
jmp 0x22c538
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c526
leaq 0x1e4174(%rip), %rax    # 0x410698
jmp 0x22c538
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c557
leaq 0xe0baa(%rip), %rax     # 0x30d0e2
movq %rax, 0x5ada61(%rip)    # 0x7d9fa0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c58c
leaq 0x2e132d(%rip), %rax    # 0x50d8b7
jmp 0x22c5b2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c5a0
leaq 0x1e59ee(%rip), %rax    # 0x411f8c
jmp 0x22c5b2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c5d1
leaq 0xe290a(%rip), %rax     # 0x30eebc
movq %rax, 0x5ad9ef(%rip)    # 0x7d9fa8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c606
leaq 0x2e3ee8(%rip), %rax    # 0x5104ec
jmp 0x22c62c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c61a
leaq 0x1e78d1(%rip), %rax    # 0x413ee9
jmp 0x22c62c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c64b
leaq 0xe4be5(%rip), %rax     # 0x311211
movq %rax, 0x5ad97d(%rip)    # 0x7d9fb0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c680
leaq 0x2e7f69(%rip), %rax    # 0x5145e7
jmp 0x22c6a6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c694
leaq 0x1ea1cd(%rip), %rax    # 0x41685f
jmp 0x22c6a6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c6c5
leaq 0xe7dbf(%rip), %rax     # 0x314465
movq %rax, 0x5ad90b(%rip)    # 0x7d9fb8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c6fa
leaq 0x2eb1b3(%rip), %rax    # 0x5178ab
jmp 0x22c720
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c70e
leaq 0x1ed8f7(%rip), %rax    # 0x41a003
jmp 0x22c720
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c73f
leaq 0xeb8df(%rip), %rax     # 0x317fff
movq %rax, 0x5ad899(%rip)    # 0x7d9fc0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c774
leaq 0x2ee813(%rip), %rax    # 0x51af85
jmp 0x22c79a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c788
leaq 0x1f0d75(%rip), %rax    # 0x41d4fb
jmp 0x22c79a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c7b9
leaq 0xef63e(%rip), %rax     # 0x31bdd8
movq %rax, 0x5ad827(%rip)    # 0x7d9fc8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c7ee
leaq 0x2f2f02(%rip), %rax    # 0x51f6ee
jmp 0x22c814
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c802
leaq 0x1f49ab(%rip), %rax    # 0x4211ab
jmp 0x22c814
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c833
leaq 0xf3ad6(%rip), %rax     # 0x3202ea
movq %rax, 0x5ad7b5(%rip)    # 0x7d9fd0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22c868
leaq 0x2f86a1(%rip), %rax    # 0x524f07
jmp 0x22c88e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22c87c
leaq 0x1f938e(%rip), %rax    # 0x425c08
jmp 0x22c88e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x22c8ad
leaq 0xf91a4(%rip), %rax     # 0x325a32
movq %rax, 0x5ad743(%rip)    # 0x7d9fd8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq