LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x5672cf
testl %eax, %eax
je 0x1bf4ca
leaq 0x2de513(%rip), %rax    # 0x49d9db
jmp 0x1bf4f0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf4de
leaq 0x1e60ba(%rip), %rax    # 0x3a5596
jmp 0x1bf4f0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf50f
leaq 0xdf749(%rip), %rax     # 0x29ec39
movq %rax, 0x57cd79(%rip)    # 0x73c270
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_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 0x5672cf
testl %eax, %eax
je 0x1bf544
leaq 0x2e0b2c(%rip), %rax    # 0x4a006e
jmp 0x1bf56a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf558
leaq 0x1e81b4(%rip), %rax    # 0x3a770a
jmp 0x1bf56a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf589
leaq 0xe1c77(%rip), %rax     # 0x2a11e1
movq %rax, 0x57cd07(%rip)    # 0x73c278
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_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 0x5672cf
testl %eax, %eax
je 0x1bf5be
leaq 0x2f2260(%rip), %rax    # 0x4b181c
jmp 0x1bf5e4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf5d2
leaq 0x1f4ac5(%rip), %rax    # 0x3b4095
jmp 0x1bf5e4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf603
leaq 0xf028a(%rip), %rax     # 0x2af86e
movq %rax, 0x57cc95(%rip)    # 0x73c280
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_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 0x5672cf
testl %eax, %eax
je 0x1bf638
leaq 0x2f42ed(%rip), %rax    # 0x4b3923
jmp 0x1bf65e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf64c
leaq 0x1f69c9(%rip), %rax    # 0x3b6013
jmp 0x1bf65e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf67d
leaq 0xf2540(%rip), %rax     # 0x2b1b9e
movq %rax, 0x57cc23(%rip)    # 0x73c288
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_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 0x5672cf
testl %eax, %eax
je 0x1bf6b2
leaq 0x2f661a(%rip), %rax    # 0x4b5cca
jmp 0x1bf6d8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf6c6
leaq 0x1f89e2(%rip), %rax    # 0x3b80a6
jmp 0x1bf6d8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf6f7
leaq 0xf4657(%rip), %rax     # 0x2b3d2f
movq %rax, 0x57cbb1(%rip)    # 0x73c290
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_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 0x5672cf
testl %eax, %eax
je 0x1bf72c
leaq 0x2f8f2d(%rip), %rax    # 0x4b8657
jmp 0x1bf752
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf740
leaq 0x1facd6(%rip), %rax    # 0x3ba414
jmp 0x1bf752
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf771
leaq 0xf6b3c(%rip), %rax     # 0x2b628e
movq %rax, 0x57cb3f(%rip)    # 0x73c298
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_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 0x5672cf
testl %eax, %eax
je 0x1bf7a6
leaq 0x2fcd87(%rip), %rax    # 0x4bc52b
jmp 0x1bf7cc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf7ba
leaq 0x1fee25(%rip), %rax    # 0x3be5dd
jmp 0x1bf7cc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf7eb
leaq 0xfae16(%rip), %rax     # 0x2ba5e2
movq %rax, 0x57cacd(%rip)    # 0x73c2a0
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_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 0x5672cf
testl %eax, %eax
je 0x1bf820
leaq 0x300b8c(%rip), %rax    # 0x4c03aa
jmp 0x1bf846
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf834
leaq 0x20291c(%rip), %rax    # 0x3c214e
jmp 0x1bf846
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf865
leaq 0xff29f(%rip), %rax     # 0x2beae5
movq %rax, 0x57ca5b(%rip)    # 0x73c2a8
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_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 0x5672cf
testl %eax, %eax
je 0x1bf89a
leaq 0x30490a(%rip), %rax    # 0x4c41a2
jmp 0x1bf8c0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf8ae
leaq 0x206359(%rip), %rax    # 0x3c5c05
jmp 0x1bf8c0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf8df
leaq 0x10319e(%rip), %rax    # 0x2c2a5e
movq %rax, 0x57c9e9(%rip)    # 0x73c2b0
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_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 0x5672cf
testl %eax, %eax
je 0x1bf914
leaq 0x308c1f(%rip), %rax    # 0x4c8531
jmp 0x1bf93a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf928
leaq 0x20a096(%rip), %rax    # 0x3c99bc
jmp 0x1bf93a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf959
leaq 0x1073cc(%rip), %rax    # 0x2c6d06
movq %rax, 0x57c977(%rip)    # 0x73c2b8
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_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 0x5672cf
testl %eax, %eax
je 0x1bf98e
leaq 0x321f1d(%rip), %rax    # 0x4e18a9
jmp 0x1bf9b4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bf9a2
leaq 0x21f54e(%rip), %rax    # 0x3deeee
jmp 0x1bf9b4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bf9d3
leaq 0x11f69a(%rip), %rax    # 0x2df04e
movq %rax, 0x57c905(%rip)    # 0x73c2c0
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_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 0x5672cf
testl %eax, %eax
je 0x1bfa08
leaq 0x325e0b(%rip), %rax    # 0x4e5811
jmp 0x1bfa2e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfa1c
leaq 0x2231d8(%rip), %rax    # 0x3e2bf2
jmp 0x1bfa2e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfa4d
leaq 0x123bda(%rip), %rax    # 0x2e3608
movq %rax, 0x57c893(%rip)    # 0x73c2c8
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_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 0x5672cf
testl %eax, %eax
je 0x1bfa82
leaq 0x329ec9(%rip), %rax    # 0x4e9949
jmp 0x1bfaa8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfa96
leaq 0x226fc6(%rip), %rax    # 0x3e6a5a
jmp 0x1bfaa8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfac7
leaq 0x127d2b(%rip), %rax    # 0x2e77d3
movq %rax, 0x57c821(%rip)    # 0x73c2d0
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_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_stats_table_striped_profile_8_pointer = parasail_sg_qb_stats_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_profile_8_pointer = parasail_sg_qb_stats_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_profile_8_pointer = parasail_sg_qb_stats_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_profile_8_pointer = parasail_sg_qb_stats_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_profile_8_pointer = parasail_sg_qb_stats_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x1bfafc
leaq 0x32e5e8(%rip), %rax    # 0x4ee0e2
jmp 0x1bfb22
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfb10
leaq 0x22b0ff(%rip), %rax    # 0x3eac0d
jmp 0x1bfb22
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfb41
leaq 0x12c28c(%rip), %rax    # 0x2ebdae
movq %rax, 0x57c7af(%rip)    # 0x73c2d8
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_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_scan_profile_64_pointer = parasail_sg_qb_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_profile_64_pointer = parasail_sg_qb_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_profile_64_pointer = parasail_sg_qb_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_profile_64_pointer = parasail_sg_qb_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_profile_64_pointer = parasail_sg_qb_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfb76
leaq 0x331765(%rip), %rax    # 0x4f12d9
jmp 0x1bfb9c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfb8a
leaq 0x22dd0e(%rip), %rax    # 0x3ed896
jmp 0x1bfb9c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfbbb
leaq 0x12f5a1(%rip), %rax    # 0x2ef13d
movq %rax, 0x57c73d(%rip)    # 0x73c2e0
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_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_scan_profile_32_pointer = parasail_sg_qb_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_profile_32_pointer = parasail_sg_qb_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_profile_32_pointer = parasail_sg_qb_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_profile_32_pointer = parasail_sg_qb_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_profile_32_pointer = parasail_sg_qb_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfbf0
leaq 0x333600(%rip), %rax    # 0x4f31ee
jmp 0x1bfc16
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfc04
leaq 0x22f9e1(%rip), %rax    # 0x3ef5e3
jmp 0x1bfc16
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfc35
leaq 0x131743(%rip), %rax    # 0x2f1359
movq %rax, 0x57c6cb(%rip)    # 0x73c2e8
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_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_scan_profile_16_pointer = parasail_sg_qb_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_profile_16_pointer = parasail_sg_qb_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_profile_16_pointer = parasail_sg_qb_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_profile_16_pointer = parasail_sg_qb_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_profile_16_pointer = parasail_sg_qb_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfc6a
leaq 0x3356ae(%rip), %rax    # 0x4f5316
jmp 0x1bfc90
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfc7e
leaq 0x2317f0(%rip), %rax    # 0x3f146c
jmp 0x1bfc90
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfcaf
leaq 0x1336c6(%rip), %rax    # 0x2f3356
movq %rax, 0x57c659(%rip)    # 0x73c2f0
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_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_scan_profile_8_pointer = parasail_sg_qb_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_profile_8_pointer = parasail_sg_qb_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_profile_8_pointer = parasail_sg_qb_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_profile_8_pointer = parasail_sg_qb_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_profile_8_pointer = parasail_sg_qb_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfce4
leaq 0x337c89(%rip), %rax    # 0x4f796b
jmp 0x1bfd0a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfcf8
leaq 0x233845(%rip), %rax    # 0x3f353b
jmp 0x1bfd0a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfd29
leaq 0x1359e7(%rip), %rax    # 0x2f56f1
movq %rax, 0x57c5e7(%rip)    # 0x73c2f8
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_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_striped_profile_64_pointer = parasail_sg_qb_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_profile_64_pointer = parasail_sg_qb_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_profile_64_pointer = parasail_sg_qb_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_profile_64_pointer = parasail_sg_qb_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_profile_64_pointer = parasail_sg_qb_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfd5e
leaq 0x349bcb(%rip), %rax    # 0x509927
jmp 0x1bfd84
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfd72
leaq 0x2402e2(%rip), %rax    # 0x400052
jmp 0x1bfd84
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfda3
leaq 0x1441f4(%rip), %rax    # 0x303f78
movq %rax, 0x57c575(%rip)    # 0x73c300
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_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_striped_profile_32_pointer = parasail_sg_qb_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_profile_32_pointer = parasail_sg_qb_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_profile_32_pointer = parasail_sg_qb_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_profile_32_pointer = parasail_sg_qb_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_profile_32_pointer = parasail_sg_qb_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfdd8
leaq 0x34b854(%rip), %rax    # 0x50b62a
jmp 0x1bfdfe
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfdec
leaq 0x241e4f(%rip), %rax    # 0x401c39
jmp 0x1bfdfe
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfe1d
leaq 0x1461ca(%rip), %rax    # 0x305fc8
movq %rax, 0x57c503(%rip)    # 0x73c308
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_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_striped_profile_16_pointer = parasail_sg_qb_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_profile_16_pointer = parasail_sg_qb_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_profile_16_pointer = parasail_sg_qb_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_profile_16_pointer = parasail_sg_qb_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_profile_16_pointer = parasail_sg_qb_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfe52
leaq 0x34d66f(%rip), %rax    # 0x50d4bf
jmp 0x1bfe78
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfe66
leaq 0x2439ec(%rip), %rax    # 0x403850
jmp 0x1bfe78
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bfe97
leaq 0x147ea5(%rip), %rax    # 0x307d1d
movq %rax, 0x57c491(%rip)    # 0x73c310
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_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_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_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_rowcol_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 0x1bfecc
leaq 0x34fa51(%rip), %rax    # 0x50f91b
jmp 0x1bfef2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bfee0
leaq 0x245825(%rip), %rax    # 0x405703
jmp 0x1bfef2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bff11
leaq 0x149f8e(%rip), %rax    # 0x309e80
movq %rax, 0x57c41f(%rip)    # 0x73c318
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