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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22adac
leaq 0x29fcb8(%rip), %rax    # 0x4caa62
jmp 0x22add2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22adc0
leaq 0x1b376a(%rip), %rax    # 0x3de528
jmp 0x22add2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22adf1
leaq 0xc3621(%rip), %rax     # 0x2ee3f3
movq %rax, 0x5791af(%rip)    # 0x7a3f88
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_db_table_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_profile_16_pointer = parasail_sg_db_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22ae26
leaq 0x2a1adb(%rip), %rax    # 0x4cc8ff
jmp 0x22ae4c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ae3a
leaq 0x1b51af(%rip), %rax    # 0x3dffe7
jmp 0x22ae4c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22ae6b
leaq 0xc5175(%rip), %rax     # 0x2effc1
movq %rax, 0x57913d(%rip)    # 0x7a3f90
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_db_table_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_profile_8_pointer = parasail_sg_db_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22aea0
leaq 0x2a3e09(%rip), %rax    # 0x4ceca7
jmp 0x22aec6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22aeb4
leaq 0x1b6ff7(%rip), %rax    # 0x3e1ea9
jmp 0x22aec6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22aee5
leaq 0xc72c5(%rip), %rax     # 0x2f218b
movq %rax, 0x5790cb(%rip)    # 0x7a3f98
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_64_pointer = parasail_sg_db_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22af1a
leaq 0x2b5168(%rip), %rax    # 0x4e0080
jmp 0x22af40
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22af2e
leaq 0x1c2cb6(%rip), %rax    # 0x3edbe2
jmp 0x22af40
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22af5f
leaq 0xd4006(%rip), %rax     # 0x2fef46
movq %rax, 0x579059(%rip)    # 0x7a3fa0
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_32_pointer = parasail_sg_db_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22af94
leaq 0x2b6ccb(%rip), %rax    # 0x4e1c5d
jmp 0x22afba
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22afa8
leaq 0x1c4462(%rip), %rax    # 0x3ef408
jmp 0x22afba
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22afd9
leaq 0xd59ff(%rip), %rax     # 0x3009b9
movq %rax, 0x578fe7(%rip)    # 0x7a3fa8
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_16_pointer = parasail_sg_db_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22b00e
leaq 0x2b8c48(%rip), %rax    # 0x4e3c54
jmp 0x22b034
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b022
leaq 0x1c5d54(%rip), %rax    # 0x3f0d74
jmp 0x22b034
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b053
leaq 0xd73b6(%rip), %rax     # 0x3023ea
movq %rax, 0x578f75(%rip)    # 0x7a3fb0
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_db_table_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_profile_8_pointer = parasail_sg_db_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_table_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22b088
leaq 0x2bb262(%rip), %rax    # 0x4e62e8
jmp 0x22b0ae
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b09c
leaq 0x1c7cb2(%rip), %rax    # 0x3f2d4c
jmp 0x22b0ae
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b0cd
leaq 0xd96dd(%rip), %rax     # 0x30478b
movq %rax, 0x578f03(%rip)    # 0x7a3fb8
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_64_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22b102
leaq 0x2bee70(%rip), %rax    # 0x4e9f70
jmp 0x22b128
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b116
leaq 0x1cb62d(%rip), %rax    # 0x3f6741
jmp 0x22b128
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b147
leaq 0xdcd04(%rip), %rax     # 0x307e2c
movq %rax, 0x578e91(%rip)    # 0x7a3fc0
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_32_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22b17c
leaq 0x2c2952(%rip), %rax    # 0x4edacc
jmp 0x22b1a2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b190
leaq 0x1cead3(%rip), %rax    # 0x3f9c61
jmp 0x22b1a2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b1c1
leaq 0xe0794(%rip), %rax     # 0x30b936
movq %rax, 0x578e1f(%rip)    # 0x7a3fc8
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_16_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22b1f6
leaq 0x2c672a(%rip), %rax    # 0x4f191e
jmp 0x22b21c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b20a
leaq 0x1d21db(%rip), %rax    # 0x3fd3e3
jmp 0x22b21c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b23b
leaq 0xe42f9(%rip), %rax     # 0x30f515
movq %rax, 0x578dad(%rip)    # 0x7a3fd0
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_profile_8_pointer = parasail_sg_db_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_stats_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22b270
leaq 0x2ca988(%rip), %rax    # 0x4f5bf6
jmp 0x22b296
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b284
leaq 0x1d614a(%rip), %rax    # 0x4013cc
jmp 0x22b296
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b2b5
leaq 0xe87c5(%rip), %rax     # 0x313a5b
movq %rax, 0x578d3b(%rip)    # 0x7a3fd8
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_table_striped_profile_64_pointer = parasail_sg_db_stats_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_profile_64_pointer = parasail_sg_db_stats_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_profile_64_pointer = parasail_sg_db_stats_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_profile_64_pointer = parasail_sg_db_stats_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_profile_64_pointer = parasail_sg_db_stats_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b2ea
leaq 0x2e549e(%rip), %rax    # 0x510786
jmp 0x22b310
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b2fe
leaq 0x1eaffc(%rip), %rax    # 0x4162f8
jmp 0x22b310
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b32f
leaq 0xff39c(%rip), %rax     # 0x32a6ac
movq %rax, 0x578cc9(%rip)    # 0x7a3fe0
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_table_striped_profile_32_pointer = parasail_sg_db_stats_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_profile_32_pointer = parasail_sg_db_stats_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_profile_32_pointer = parasail_sg_db_stats_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_profile_32_pointer = parasail_sg_db_stats_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_profile_32_pointer = parasail_sg_db_stats_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b364
leaq 0x2e8d57(%rip), %rax    # 0x5140b9
jmp 0x22b38a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b378
leaq 0x1ee2ae(%rip), %rax    # 0x419624
jmp 0x22b38a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b3a9
leaq 0x102d0d(%rip), %rax    # 0x32e097
movq %rax, 0x578c57(%rip)    # 0x7a3fe8
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_table_striped_profile_16_pointer = parasail_sg_db_stats_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_profile_16_pointer = parasail_sg_db_stats_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_profile_16_pointer = parasail_sg_db_stats_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_profile_16_pointer = parasail_sg_db_stats_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_profile_16_pointer = parasail_sg_db_stats_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b3de
leaq 0x2ed414(%rip), %rax    # 0x5187f0
jmp 0x22b404
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b3f2
leaq 0x1f1c23(%rip), %rax    # 0x41d013
jmp 0x22b404
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b423
leaq 0x1069a8(%rip), %rax    # 0x331dac
movq %rax, 0x578be5(%rip)    # 0x7a3ff0
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_table_striped_profile_8_pointer = parasail_sg_db_stats_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_profile_8_pointer = parasail_sg_db_stats_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_profile_8_pointer = parasail_sg_db_stats_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_profile_8_pointer = parasail_sg_db_stats_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_profile_8_pointer = parasail_sg_db_stats_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b458
leaq 0x2f1e94(%rip), %rax    # 0x51d2ea
jmp 0x22b47e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b46c
leaq 0x1f691d(%rip), %rax    # 0x421d87
jmp 0x22b47e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b49d
leaq 0x10ba6d(%rip), %rax    # 0x336eeb
movq %rax, 0x578b73(%rip)    # 0x7a3ff8
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_rowcol_scan_profile_64_pointer = parasail_sg_db_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_profile_64_pointer = parasail_sg_db_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_profile_64_pointer = parasail_sg_db_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_profile_64_pointer = parasail_sg_db_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_profile_64_pointer = parasail_sg_db_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b4d2
leaq 0x2f51ad(%rip), %rax    # 0x52067d
jmp 0x22b4f8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b4e6
leaq 0x1f9952(%rip), %rax    # 0x424e36
jmp 0x22b4f8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b517
leaq 0x10eea6(%rip), %rax    # 0x33a39e
movq %rax, 0x578b01(%rip)    # 0x7a4000
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_rowcol_scan_profile_32_pointer = parasail_sg_db_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_profile_32_pointer = parasail_sg_db_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_profile_32_pointer = parasail_sg_db_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_profile_32_pointer = parasail_sg_db_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_profile_32_pointer = parasail_sg_db_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b54c
leaq 0x2f6fcc(%rip), %rax    # 0x522516
jmp 0x22b572
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b560
leaq 0x1fb307(%rip), %rax    # 0x426865
jmp 0x22b572
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b591
leaq 0x110ad1(%rip), %rax    # 0x33c043
movq %rax, 0x578a8f(%rip)    # 0x7a4008
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_rowcol_scan_profile_16_pointer = parasail_sg_db_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_profile_16_pointer = parasail_sg_db_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_profile_16_pointer = parasail_sg_db_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_profile_16_pointer = parasail_sg_db_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_profile_16_pointer = parasail_sg_db_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b5c6
leaq 0x2f8c28(%rip), %rax    # 0x5241ec
jmp 0x22b5ec
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b5da
leaq 0x1fcc56(%rip), %rax    # 0x42822e
jmp 0x22b5ec
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b60b
leaq 0x112540(%rip), %rax    # 0x33db2c
movq %rax, 0x578a1d(%rip)    # 0x7a4010
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_rowcol_scan_profile_8_pointer = parasail_sg_db_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_profile_8_pointer = parasail_sg_db_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_profile_8_pointer = parasail_sg_db_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_profile_8_pointer = parasail_sg_db_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_profile_8_pointer = parasail_sg_db_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b640
leaq 0x2fae6e(%rip), %rax    # 0x5264ac
jmp 0x22b666
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b654
leaq 0x1fe882(%rip), %rax    # 0x429ed4
jmp 0x22b666
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b685
leaq 0x1143bd(%rip), %rax    # 0x33fa23
movq %rax, 0x5789ab(%rip)    # 0x7a4018
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_rowcol_striped_profile_64_pointer = parasail_sg_db_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_striped_profile_64_pointer = parasail_sg_db_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_striped_profile_64_pointer = parasail_sg_db_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_striped_profile_64_pointer = parasail_sg_db_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_striped_profile_64_pointer = parasail_sg_db_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b6ba
leaq 0x30d335(%rip), %rax    # 0x5389ed
jmp 0x22b6e0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b6ce
leaq 0x20acc4(%rip), %rax    # 0x436390
jmp 0x22b6e0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b6ff
leaq 0x12165d(%rip), %rax    # 0x34cd3d
movq %rax, 0x578939(%rip)    # 0x7a4020
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_rowcol_striped_profile_32_pointer = parasail_sg_db_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_striped_profile_32_pointer = parasail_sg_db_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_striped_profile_32_pointer = parasail_sg_db_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_striped_profile_32_pointer = parasail_sg_db_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_striped_profile_32_pointer = parasail_sg_db_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b734
leaq 0x30edc0(%rip), %rax    # 0x53a4f2
jmp 0x22b75a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b748
leaq 0x20c4fe(%rip), %rax    # 0x437c44
jmp 0x22b75a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b779
leaq 0x122ffc(%rip), %rax    # 0x34e756
movq %rax, 0x5788c7(%rip)    # 0x7a4028
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_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_rowcol_striped_profile_16_pointer = parasail_sg_db_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_striped_profile_16_pointer = parasail_sg_db_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_striped_profile_16_pointer = parasail_sg_db_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_striped_profile_16_pointer = parasail_sg_db_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_striped_profile_16_pointer = parasail_sg_db_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_db_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 0x594f9c
testl %eax, %eax
je 0x22b7ae
leaq 0x3107e3(%rip), %rax    # 0x53bf8f
jmp 0x22b7d4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22b7c2
leaq 0x20dc69(%rip), %rax    # 0x439429
jmp 0x22b7d4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22b7f3
leaq 0x12482d(%rip), %rax    # 0x350001
movq %rax, 0x578855(%rip)    # 0x7a4030
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