LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21da24
leaq 0x2ad6f2(%rip), %rax    # 0x4cb114
jmp 0x21da4a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21da38
leaq 0x1bdc7f(%rip), %rax    # 0x3db6b5
jmp 0x21da4a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21da69
leaq 0xafc46(%rip), %rax     # 0x2cd690
movq %rax, 0x5bb7d7(%rip)    # 0x7d9228
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21da9e
leaq 0x2b0e44(%rip), %rax    # 0x4ce8e0
jmp 0x21dac4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21dab2
leaq 0x1c1051(%rip), %rax    # 0x3deb01
jmp 0x21dac4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21dae3
leaq 0xb37fe(%rip), %rax     # 0x2d12c2
movq %rax, 0x5bb765(%rip)    # 0x7d9230
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21db18
leaq 0x2b50c4(%rip), %rax    # 0x4d2bda
jmp 0x21db3e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21db2c
leaq 0x1c4860(%rip), %rax    # 0x3e238a
jmp 0x21db3e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21db5d
leaq 0xb7d07(%rip), %rax     # 0x2d5845
movq %rax, 0x5bb6f3(%rip)    # 0x7d9238
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21db92
leaq 0x2c80fa(%rip), %rax    # 0x4e5c8a
jmp 0x21dbb8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21dba6
leaq 0x1d5823(%rip), %rax    # 0x3f33c7
jmp 0x21dbb8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21dbd7
leaq 0xcbf40(%rip), %rax     # 0x2e9af8
movq %rax, 0x5bb681(%rip)    # 0x7d9240
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21dc0c
leaq 0x2cadbc(%rip), %rax    # 0x4e89c6
jmp 0x21dc32
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21dc20
leaq 0x1d8629(%rip), %rax    # 0x3f6247
jmp 0x21dc32
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21dc51
leaq 0xcf885(%rip), %rax     # 0x2ed4b7
movq %rax, 0x5bb60f(%rip)    # 0x7d9248
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21dc86
leaq 0x2ce4d8(%rip), %rax    # 0x4ec15c
jmp 0x21dcac
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21dc9a
leaq 0x1db7c0(%rip), %rax    # 0x3f9458
jmp 0x21dcac
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21dccb
leaq 0xd2f40(%rip), %rax     # 0x2f0bec
movq %rax, 0x5bb59d(%rip)    # 0x7d9250
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21dd00
leaq 0x2d2b75(%rip), %rax    # 0x4f0873
jmp 0x21dd26
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21dd14
leaq 0x1ded44(%rip), %rax    # 0x3fca56
jmp 0x21dd26
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21dd45
leaq 0xd6fec(%rip), %rax     # 0x2f4d12
movq %rax, 0x5bb52b(%rip)    # 0x7d9258
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21dd7a
leaq 0x2d5f7d(%rip), %rax    # 0x4f3cf5
jmp 0x21dda0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21dd8e
leaq 0x1e0f35(%rip), %rax    # 0x3fecc1
jmp 0x21dda0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21ddbf
leaq 0xdaaab(%rip), %rax     # 0x2f884b
movq %rax, 0x5bb4b9(%rip)    # 0x7d9260
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21ddf4
leaq 0x2d7bc6(%rip), %rax    # 0x4f59b8
jmp 0x21de1a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21de08
leaq 0x1e2a52(%rip), %rax    # 0x400858
jmp 0x21de1a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21de39
leaq 0xdca8d(%rip), %rax     # 0x2fa8a7
movq %rax, 0x5bb447(%rip)    # 0x7d9268
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21de6e
leaq 0x2da72b(%rip), %rax    # 0x4f8597
jmp 0x21de94
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21de82
leaq 0x1e4a1b(%rip), %rax    # 0x40289b
jmp 0x21de94
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21deb3
leaq 0xdeea5(%rip), %rax     # 0x2fcd39
movq %rax, 0x5bb3d5(%rip)    # 0x7d9270
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_table_scan_profile_8_pointer = parasail_sg_qb_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_profile_8_pointer = parasail_sg_qb_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_profile_8_pointer = parasail_sg_qb_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_profile_8_pointer = parasail_sg_qb_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_profile_8_pointer = parasail_sg_qb_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21dee8
leaq 0x2de54d(%rip), %rax    # 0x4fc433
jmp 0x21df0e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21defc
leaq 0x1e719a(%rip), %rax    # 0x405094
jmp 0x21df0e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21df2d
leaq 0xe1f76(%rip), %rax     # 0x2ffe84
movq %rax, 0x5bb363(%rip)    # 0x7d9278
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_table_striped_profile_64_pointer = parasail_sg_qb_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_profile_64_pointer = parasail_sg_qb_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_profile_64_pointer = parasail_sg_qb_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_profile_64_pointer = parasail_sg_qb_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_profile_64_pointer = parasail_sg_qb_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21df62
leaq 0x2ede67(%rip), %rax    # 0x50bdc7
jmp 0x21df88
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21df76
leaq 0x1f26d4(%rip), %rax    # 0x410648
jmp 0x21df88
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21dfa7
leaq 0xef10a(%rip), %rax     # 0x30d092
movq %rax, 0x5bb2f1(%rip)    # 0x7d9280
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_table_striped_profile_32_pointer = parasail_sg_qb_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_profile_32_pointer = parasail_sg_qb_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_profile_32_pointer = parasail_sg_qb_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_profile_32_pointer = parasail_sg_qb_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_profile_32_pointer = parasail_sg_qb_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21dfdc
leaq 0x2ef88d(%rip), %rax    # 0x50d867
jmp 0x21e002
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21dff0
leaq 0x1f3f4e(%rip), %rax    # 0x411f3c
jmp 0x21e002
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e021
leaq 0xf0e6a(%rip), %rax     # 0x30ee6c
movq %rax, 0x5bb27f(%rip)    # 0x7d9288
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_table_striped_profile_16_pointer = parasail_sg_qb_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_profile_16_pointer = parasail_sg_qb_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_profile_16_pointer = parasail_sg_qb_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_profile_16_pointer = parasail_sg_qb_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_profile_16_pointer = parasail_sg_qb_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21e056
leaq 0x2f2448(%rip), %rax    # 0x51049c
jmp 0x21e07c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e06a
leaq 0x1f5e31(%rip), %rax    # 0x413e99
jmp 0x21e07c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e09b
leaq 0xf3145(%rip), %rax     # 0x3111c1
movq %rax, 0x5bb20d(%rip)    # 0x7d9290
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_table_striped_profile_8_pointer = parasail_sg_qb_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_profile_8_pointer = parasail_sg_qb_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_profile_8_pointer = parasail_sg_qb_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_profile_8_pointer = parasail_sg_qb_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_profile_8_pointer = parasail_sg_qb_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21e0d0
leaq 0x2f64c9(%rip), %rax    # 0x514597
jmp 0x21e0f6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e0e4
leaq 0x1f872d(%rip), %rax    # 0x41680f
jmp 0x21e0f6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e115
leaq 0xf631f(%rip), %rax     # 0x314415
movq %rax, 0x5bb19b(%rip)    # 0x7d9298
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_table_scan_profile_64_pointer = parasail_sg_qb_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_profile_64_pointer = parasail_sg_qb_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_profile_64_pointer = parasail_sg_qb_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_profile_64_pointer = parasail_sg_qb_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_profile_64_pointer = parasail_sg_qb_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21e14a
leaq 0x2f9713(%rip), %rax    # 0x51785b
jmp 0x21e170
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e15e
leaq 0x1fbe57(%rip), %rax    # 0x419fb3
jmp 0x21e170
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e18f
leaq 0xf9e3f(%rip), %rax     # 0x317faf
movq %rax, 0x5bb129(%rip)    # 0x7d92a0
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_table_scan_profile_32_pointer = parasail_sg_qb_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_profile_32_pointer = parasail_sg_qb_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_profile_32_pointer = parasail_sg_qb_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_profile_32_pointer = parasail_sg_qb_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_profile_32_pointer = parasail_sg_qb_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21e1c4
leaq 0x2fcd73(%rip), %rax    # 0x51af35
jmp 0x21e1ea
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e1d8
leaq 0x1ff2d5(%rip), %rax    # 0x41d4ab
jmp 0x21e1ea
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e209
leaq 0xfdb9e(%rip), %rax     # 0x31bd88
movq %rax, 0x5bb0b7(%rip)    # 0x7d92a8
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_table_scan_profile_16_pointer = parasail_sg_qb_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_profile_16_pointer = parasail_sg_qb_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_profile_16_pointer = parasail_sg_qb_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_profile_16_pointer = parasail_sg_qb_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_profile_16_pointer = parasail_sg_qb_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21e23e
leaq 0x301462(%rip), %rax    # 0x51f69e
jmp 0x21e264
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e252
leaq 0x202f0b(%rip), %rax    # 0x42115b
jmp 0x21e264
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e283
leaq 0x102036(%rip), %rax    # 0x32029a
movq %rax, 0x5bb045(%rip)    # 0x7d92b0
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_stats_table_scan_profile_8_pointer = parasail_sg_qb_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_profile_8_pointer = parasail_sg_qb_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_profile_8_pointer = parasail_sg_qb_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_profile_8_pointer = parasail_sg_qb_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_profile_8_pointer = parasail_sg_qb_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21e2b8
leaq 0x306c01(%rip), %rax    # 0x524eb7
jmp 0x21e2de
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e2cc
leaq 0x2078ee(%rip), %rax    # 0x425bb8
jmp 0x21e2de
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e2fd
leaq 0x107704(%rip), %rax    # 0x3259e2
movq %rax, 0x5bafd3(%rip)    # 0x7d92b8
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_stats_table_striped_profile_64_pointer = parasail_sg_qb_stats_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_profile_64_pointer = parasail_sg_qb_stats_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_profile_64_pointer = parasail_sg_qb_stats_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_profile_64_pointer = parasail_sg_qb_stats_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_profile_64_pointer = parasail_sg_qb_stats_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x21e332
leaq 0x31faec(%rip), %rax    # 0x53de1c
jmp 0x21e358
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e346
leaq 0x21c03a(%rip), %rax    # 0x43a37e
jmp 0x21e358
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e377
leaq 0x11edc7(%rip), %rax    # 0x33d11f
movq %rax, 0x5baf61(%rip)    # 0x7d92c0
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_stats_table_striped_profile_32_pointer = parasail_sg_qb_stats_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_profile_32_pointer = parasail_sg_qb_stats_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_profile_32_pointer = parasail_sg_qb_stats_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_profile_32_pointer = parasail_sg_qb_stats_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_profile_32_pointer = parasail_sg_qb_stats_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x21e3ac
leaq 0x3230cd(%rip), %rax    # 0x541477
jmp 0x21e3d2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e3c0
leaq 0x21f3e4(%rip), %rax    # 0x43d7a2
jmp 0x21e3d2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e3f1
leaq 0x122be4(%rip), %rax    # 0x340fb6
movq %rax, 0x5baeef(%rip)    # 0x7d92c8
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_stats_table_striped_profile_16_pointer = parasail_sg_qb_stats_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_profile_16_pointer = parasail_sg_qb_stats_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_profile_16_pointer = parasail_sg_qb_stats_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_profile_16_pointer = parasail_sg_qb_stats_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_profile_16_pointer = parasail_sg_qb_stats_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x21e426
leaq 0x3280fe(%rip), %rax    # 0x546522
jmp 0x21e44c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21e43a
leaq 0x223326(%rip), %rax    # 0x44175e
jmp 0x21e44c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21e46b
leaq 0x127081(%rip), %rax    # 0x3454cd
movq %rax, 0x5bae7d(%rip)    # 0x7d92d0
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