LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_striped_profile_8_pointer = parasail_sg_qb_db_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_profile_8_pointer = parasail_sg_qb_db_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_profile_8_pointer = parasail_sg_qb_db_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_profile_8_pointer = parasail_sg_qb_db_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_profile_8_pointer = parasail_sg_qb_db_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e540c
leaq 0x2858ef(%rip), %rax    # 0x46acf9
jmp 0x1e5432
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5420
leaq 0x190aba(%rip), %rax    # 0x375ed8
jmp 0x1e5432
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5451
leaq 0x82860(%rip), %rax     # 0x267c92
movq %rax, 0x5590df(%rip)    # 0x73e518
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_scan_profile_64_pointer = parasail_sg_qb_db_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_profile_64_pointer = parasail_sg_qb_db_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_profile_64_pointer = parasail_sg_qb_db_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_profile_64_pointer = parasail_sg_qb_db_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_profile_64_pointer = parasail_sg_qb_db_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5486
leaq 0x288eb8(%rip), %rax    # 0x46e33c
jmp 0x1e54ac
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e549a
leaq 0x1944ef(%rip), %rax    # 0x379987
jmp 0x1e54ac
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e54cb
leaq 0x86598(%rip), %rax     # 0x26ba44
movq %rax, 0x55906d(%rip)    # 0x73e520
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_scan_profile_32_pointer = parasail_sg_qb_db_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_profile_32_pointer = parasail_sg_qb_db_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_profile_32_pointer = parasail_sg_qb_db_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_profile_32_pointer = parasail_sg_qb_db_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_profile_32_pointer = parasail_sg_qb_db_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5500
leaq 0x28c5e7(%rip), %rax    # 0x471ae5
jmp 0x1e5526
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5514
leaq 0x197b20(%rip), %rax    # 0x37d032
jmp 0x1e5526
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5545
leaq 0x8a4ff(%rip), %rax     # 0x26fa25
movq %rax, 0x558ffb(%rip)    # 0x73e528
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_scan_profile_16_pointer = parasail_sg_qb_db_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_profile_16_pointer = parasail_sg_qb_db_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_profile_16_pointer = parasail_sg_qb_db_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_profile_16_pointer = parasail_sg_qb_db_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_profile_16_pointer = parasail_sg_qb_db_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e557a
leaq 0x28f89e(%rip), %rax    # 0x474e16
jmp 0x1e55a0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e558e
leaq 0x19adf1(%rip), %rax    # 0x38037d
jmp 0x1e55a0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e55bf
leaq 0x8dc56(%rip), %rax     # 0x2731f6
movq %rax, 0x558f89(%rip)    # 0x73e530
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_scan_profile_8_pointer = parasail_sg_qb_db_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_profile_8_pointer = parasail_sg_qb_db_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_profile_8_pointer = parasail_sg_qb_db_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_profile_8_pointer = parasail_sg_qb_db_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_profile_8_pointer = parasail_sg_qb_db_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e55f4
leaq 0x292b58(%rip), %rax    # 0x47814a
jmp 0x1e561a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5608
leaq 0x19e126(%rip), %rax    # 0x38372c
jmp 0x1e561a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5639
leaq 0x9153b(%rip), %rax     # 0x276b55
movq %rax, 0x558f17(%rip)    # 0x73e538
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_striped_profile_64_pointer = parasail_sg_qb_db_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_profile_64_pointer = parasail_sg_qb_db_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_profile_64_pointer = parasail_sg_qb_db_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_profile_64_pointer = parasail_sg_qb_db_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_profile_64_pointer = parasail_sg_qb_db_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e566e
leaq 0x2a6b23(%rip), %rax    # 0x48c18f
jmp 0x1e5694
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5682
leaq 0x1b0311(%rip), %rax    # 0x395991
jmp 0x1e5694
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e56b3
leaq 0xa66c3(%rip), %rax     # 0x28bd57
movq %rax, 0x558ea5(%rip)    # 0x73e540
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_striped_profile_32_pointer = parasail_sg_qb_db_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_profile_32_pointer = parasail_sg_qb_db_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_profile_32_pointer = parasail_sg_qb_db_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_profile_32_pointer = parasail_sg_qb_db_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_profile_32_pointer = parasail_sg_qb_db_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e56e8
leaq 0x2a9ec5(%rip), %rax    # 0x48f5ab
jmp 0x1e570e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e56fc
leaq 0x1b377a(%rip), %rax    # 0x398e74
jmp 0x1e570e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e572d
leaq 0xaa38b(%rip), %rax     # 0x28fa99
movq %rax, 0x558e33(%rip)    # 0x73e548
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_striped_profile_16_pointer = parasail_sg_qb_db_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_profile_16_pointer = parasail_sg_qb_db_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_profile_16_pointer = parasail_sg_qb_db_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_profile_16_pointer = parasail_sg_qb_db_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_profile_16_pointer = parasail_sg_qb_db_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5762
leaq 0x2acf86(%rip), %rax    # 0x4926e6
jmp 0x1e5788
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5776
leaq 0x1b698c(%rip), %rax    # 0x39c100
jmp 0x1e5788
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e57a7
leaq 0xad90d(%rip), %rax     # 0x293095
movq %rax, 0x558dc1(%rip)    # 0x73e550
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_striped_profile_8_pointer = parasail_sg_qb_db_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_profile_8_pointer = parasail_sg_qb_db_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_profile_8_pointer = parasail_sg_qb_db_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_profile_8_pointer = parasail_sg_qb_db_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_profile_8_pointer = parasail_sg_qb_db_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e57dc
leaq 0x2b0139(%rip), %rax    # 0x495913
jmp 0x1e5802
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e57f0
leaq 0x1b9bea(%rip), %rax    # 0x39f3d8
jmp 0x1e5802
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5821
leaq 0xb10d5(%rip), %rax     # 0x2968d7
movq %rax, 0x558d4f(%rip)    # 0x73e558
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_profile_64_pointer = parasail_sg_qb_db_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_profile_64_pointer = parasail_sg_qb_db_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_profile_64_pointer = parasail_sg_qb_db_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_profile_64_pointer = parasail_sg_qb_db_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_profile_64_pointer = parasail_sg_qb_db_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5856
leaq 0x2b4104(%rip), %rax    # 0x499958
jmp 0x1e587c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e586a
leaq 0x1bc290(%rip), %rax    # 0x3a1af8
jmp 0x1e587c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e589b
leaq 0xb5320(%rip), %rax     # 0x29ab9c
movq %rax, 0x558cdd(%rip)    # 0x73e560
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_profile_32_pointer = parasail_sg_qb_db_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_profile_32_pointer = parasail_sg_qb_db_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_profile_32_pointer = parasail_sg_qb_db_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_profile_32_pointer = parasail_sg_qb_db_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_profile_32_pointer = parasail_sg_qb_db_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e58d0
leaq 0x2b6011(%rip), %rax    # 0x49b8df
jmp 0x1e58f6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e58e4
leaq 0x1bdee9(%rip), %rax    # 0x3a37cb
jmp 0x1e58f6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5915
leaq 0xb742f(%rip), %rax     # 0x29cd25
movq %rax, 0x558c6b(%rip)    # 0x73e568
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_profile_16_pointer = parasail_sg_qb_db_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_profile_16_pointer = parasail_sg_qb_db_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_profile_16_pointer = parasail_sg_qb_db_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_profile_16_pointer = parasail_sg_qb_db_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_profile_16_pointer = parasail_sg_qb_db_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e594a
leaq 0x2b8187(%rip), %rax    # 0x49dacf
jmp 0x1e5970
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e595e
leaq 0x1bfd2e(%rip), %rax    # 0x3a568a
jmp 0x1e5970
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e598f
leaq 0xb93bd(%rip), %rax     # 0x29ed2d
movq %rax, 0x558bf9(%rip)    # 0x73e570
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_profile_8_pointer = parasail_sg_qb_db_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_profile_8_pointer = parasail_sg_qb_db_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_profile_8_pointer = parasail_sg_qb_db_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_profile_8_pointer = parasail_sg_qb_db_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_profile_8_pointer = parasail_sg_qb_db_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e59c4
leaq 0x2ba7a0(%rip), %rax    # 0x4a0162
jmp 0x1e59ea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e59d8
leaq 0x1c1e28(%rip), %rax    # 0x3a77fe
jmp 0x1e59ea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5a09
leaq 0xbb8eb(%rip), %rax     # 0x2a12d5
movq %rax, 0x558b87(%rip)    # 0x73e578
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_profile_64_pointer = parasail_sg_qb_db_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_profile_64_pointer = parasail_sg_qb_db_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_profile_64_pointer = parasail_sg_qb_db_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_profile_64_pointer = parasail_sg_qb_db_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_profile_64_pointer = parasail_sg_qb_db_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5a3e
leaq 0x2cbed4(%rip), %rax    # 0x4b1910
jmp 0x1e5a64
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5a52
leaq 0x1ce739(%rip), %rax    # 0x3b4189
jmp 0x1e5a64
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5a83
leaq 0xc9efe(%rip), %rax     # 0x2af962
movq %rax, 0x558b15(%rip)    # 0x73e580
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_profile_32_pointer = parasail_sg_qb_db_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_profile_32_pointer = parasail_sg_qb_db_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_profile_32_pointer = parasail_sg_qb_db_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_profile_32_pointer = parasail_sg_qb_db_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_profile_32_pointer = parasail_sg_qb_db_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5ab8
leaq 0x2cdf61(%rip), %rax    # 0x4b3a17
jmp 0x1e5ade
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5acc
leaq 0x1d063d(%rip), %rax    # 0x3b6107
jmp 0x1e5ade
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5afd
leaq 0xcc1b4(%rip), %rax     # 0x2b1c92
movq %rax, 0x558aa3(%rip)    # 0x73e588
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_profile_16_pointer = parasail_sg_qb_db_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_profile_16_pointer = parasail_sg_qb_db_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_profile_16_pointer = parasail_sg_qb_db_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_profile_16_pointer = parasail_sg_qb_db_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_profile_16_pointer = parasail_sg_qb_db_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5b32
leaq 0x2d028e(%rip), %rax    # 0x4b5dbe
jmp 0x1e5b58
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5b46
leaq 0x1d2656(%rip), %rax    # 0x3b819a
jmp 0x1e5b58
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5b77
leaq 0xce2cb(%rip), %rax     # 0x2b3e23
movq %rax, 0x558a31(%rip)    # 0x73e590
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_profile_8_pointer = parasail_sg_qb_db_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_profile_8_pointer = parasail_sg_qb_db_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_profile_8_pointer = parasail_sg_qb_db_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_profile_8_pointer = parasail_sg_qb_db_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_profile_8_pointer = parasail_sg_qb_db_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5bac
leaq 0x2d2ba1(%rip), %rax    # 0x4b874b
jmp 0x1e5bd2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5bc0
leaq 0x1d494a(%rip), %rax    # 0x3ba508
jmp 0x1e5bd2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5bf1
leaq 0xd07b0(%rip), %rax     # 0x2b6382
movq %rax, 0x5589bf(%rip)    # 0x73e598
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_table_scan_profile_64_pointer = parasail_sg_qb_db_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_table_scan_profile_64_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_table_scan_profile_64_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_table_scan_profile_64_pointer = parasail_sg_qb_db_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_table_scan_profile_64_pointer = parasail_sg_qb_db_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5c26
leaq 0x2d69fb(%rip), %rax    # 0x4bc61f
jmp 0x1e5c4c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5c3a
leaq 0x1d8a99(%rip), %rax    # 0x3be6d1
jmp 0x1e5c4c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5c6b
leaq 0xd4a8a(%rip), %rax     # 0x2ba6d6
movq %rax, 0x55894d(%rip)    # 0x73e5a0
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_table_scan_profile_32_pointer = parasail_sg_qb_db_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_table_scan_profile_32_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_table_scan_profile_32_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_table_scan_profile_32_pointer = parasail_sg_qb_db_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_table_scan_profile_32_pointer = parasail_sg_qb_db_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5ca0
leaq 0x2da800(%rip), %rax    # 0x4c049e
jmp 0x1e5cc6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5cb4
leaq 0x1dc590(%rip), %rax    # 0x3c2242
jmp 0x1e5cc6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5ce5
leaq 0xd8f13(%rip), %rax     # 0x2bebd9
movq %rax, 0x5588db(%rip)    # 0x73e5a8
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_table_scan_profile_16_pointer = parasail_sg_qb_db_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_table_scan_profile_16_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_table_scan_profile_16_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_table_scan_profile_16_pointer = parasail_sg_qb_db_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_table_scan_profile_16_pointer = parasail_sg_qb_db_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5d1a
leaq 0x2de57e(%rip), %rax    # 0x4c4296
jmp 0x1e5d40
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5d2e
leaq 0x1dffcd(%rip), %rax    # 0x3c5cf9
jmp 0x1e5d40
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5d5f
leaq 0xdce12(%rip), %rax     # 0x2c2b52
movq %rax, 0x558869(%rip)    # 0x73e5b0
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_table_scan_profile_8_pointer = parasail_sg_qb_db_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_table_scan_profile_8_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_table_scan_profile_8_pointer = parasail_sg_qb_db_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_table_scan_profile_8_pointer = parasail_sg_qb_db_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_table_scan_profile_8_pointer = parasail_sg_qb_db_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1e5d94
leaq 0x2e2893(%rip), %rax    # 0x4c8625
jmp 0x1e5dba
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e5da8
leaq 0x1e3d0a(%rip), %rax    # 0x3c9ab0
jmp 0x1e5dba
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1e5dd9
leaq 0xe1040(%rip), %rax     # 0x2c6dfa
movq %rax, 0x5587f7(%rip)    # 0x73e5b8
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