LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x5c8fdb
testl %eax, %eax
je 0x21522c
leaq 0x38699f(%rip), %rax    # 0x59bbc9
jmp 0x215252
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215240
leaq 0x2731f6(%rip), %rax    # 0x488434
jmp 0x215252
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x215271
leaq 0x181b9d(%rip), %rax    # 0x396def
movq %rax, 0x5c382f(%rip)    # 0x7d8a88
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x5c8fdb
testl %eax, %eax
je 0x2152a6
leaq 0x38b10a(%rip), %rax    # 0x5a03ae
jmp 0x2152cc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2152ba
leaq 0x276af8(%rip), %rax    # 0x48bdb0
jmp 0x2152cc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2152eb
leaq 0x185b38(%rip), %rax    # 0x39ae04
movq %rax, 0x5c37bd(%rip)    # 0x7d8a90
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x5c8fdb
testl %eax, %eax
je 0x215320
leaq 0x39089b(%rip), %rax    # 0x5a5bb9
jmp 0x215346
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215334
leaq 0x27b213(%rip), %rax    # 0x490545
jmp 0x215346
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x215365
leaq 0x18abe0(%rip), %rax    # 0x39ff26
movq %rax, 0x5c374b(%rip)    # 0x7d8a98
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21539a
leaq 0x393061(%rip), %rax    # 0x5a83f9
jmp 0x2153c0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2153ae
leaq 0x27dc90(%rip), %rax    # 0x49303c
jmp 0x2153c0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2153df
leaq 0x18dda9(%rip), %rax    # 0x3a3169
movq %rax, 0x5c36d9(%rip)    # 0x7d8aa0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215414
leaq 0x394cb1(%rip), %rax    # 0x5aa0c3
jmp 0x21543a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215428
leaq 0x27f8ac(%rip), %rax    # 0x494cd2
jmp 0x21543a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x215459
leaq 0x18ff4e(%rip), %rax    # 0x3a5388
movq %rax, 0x5c3667(%rip)    # 0x7d8aa8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21548e
leaq 0x39732a(%rip), %rax    # 0x5ac7b6
jmp 0x2154b4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2154a2
leaq 0x281752(%rip), %rax    # 0x496bf2
jmp 0x2154b4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2154d3
leaq 0x19229d(%rip), %rax    # 0x3a7751
movq %rax, 0x5c35f5(%rip)    # 0x7d8ab0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215508
leaq 0x39a751(%rip), %rax    # 0x5afc57
jmp 0x21552e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21551c
leaq 0x283a04(%rip), %rax    # 0x498f1e
jmp 0x21552e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x21554d
leaq 0x194e08(%rip), %rax    # 0x3aa336
movq %rax, 0x5c3583(%rip)    # 0x7d8ab8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215582
leaq 0x3aa779(%rip), %rax    # 0x5bfcf9
jmp 0x2155a8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215596
leaq 0x28f8d5(%rip), %rax    # 0x4a4e69
jmp 0x2155a8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2155c7
leaq 0x1a2c2f(%rip), %rax    # 0x3b81d7
movq %rax, 0x5c3511(%rip)    # 0x7d8ac0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2155fc
leaq 0x3ac870(%rip), %rax    # 0x5c1e6a
jmp 0x215622
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215610
leaq 0x291a7e(%rip), %rax    # 0x4a708c
jmp 0x215622
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x215641
leaq 0x1a551e(%rip), %rax    # 0x3bab40
movq %rax, 0x5c349f(%rip)    # 0x7d8ac8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215676
leaq 0x3af44e(%rip), %rax    # 0x5c4ac2
jmp 0x21569c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21568a
leaq 0x293ee6(%rip), %rax    # 0x4a956e
jmp 0x21569c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2156bb
leaq 0x1a7e4a(%rip), %rax    # 0x3bd4e6
movq %rax, 0x5c342d(%rip)    # 0x7d8ad0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2156f0
leaq 0x3b2e36(%rip), %rax    # 0x5c8524
jmp 0x215716
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215704
leaq 0x29675d(%rip), %rax    # 0x4abe5f
jmp 0x215716
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x215735
leaq 0x1aafe3(%rip), %rax    # 0x3c06f9
movq %rax, 0x5c33bb(%rip)    # 0x7d8ad8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_64_dispatcher
parasail_result_t* parasail_sw_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215c5d
leaq 0x297d31(%rip), %rax    # 0x4ad98c
jmp 0x215c8c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215c71
leaq 0x1ac865(%rip), %rax    # 0x3c24d4
jmp 0x215c8c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x215c85
leaq 0x86839(%rip), %rax     # 0x29c4bc
jmp 0x215c8c
leaq 0x99ad4(%rip), %rax     # 0x2af760
movq %rax, 0x5c2e4d(%rip)    # 0x7d8ae0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_32_dispatcher
parasail_result_t* parasail_sw_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215ce6
leaq 0x2995a8(%rip), %rax    # 0x4af28c
jmp 0x215d15
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215cfa
leaq 0x1ae1a8(%rip), %rax    # 0x3c3ea0
jmp 0x215d15
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x215d0e
leaq 0x867b0(%rip), %rax     # 0x29c4bc
jmp 0x215d15
leaq 0x9b8f3(%rip), %rax     # 0x2b1608
movq %rax, 0x5c2dcc(%rip)    # 0x7d8ae8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_16_dispatcher
parasail_result_t* parasail_sw_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215d6f
leaq 0x29b917(%rip), %rax    # 0x4b1684
jmp 0x215d9e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215d83
leaq 0x1afcff(%rip), %rax    # 0x3c5a80
jmp 0x215d9e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x215d97
leaq 0x86727(%rip), %rax     # 0x29c4bc
jmp 0x215d9e
leaq 0x9d942(%rip), %rax     # 0x2b36e0
movq %rax, 0x5c2d4b(%rip)    # 0x7d8af0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_8_dispatcher
parasail_result_t* parasail_sw_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215df8
leaq 0x29ea76(%rip), %rax    # 0x4b486c
jmp 0x215e27
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215e0c
leaq 0x1b1c7a(%rip), %rax    # 0x3c7a84
jmp 0x215e27
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x215e20
leaq 0x8669e(%rip), %rax     # 0x29c4bc
jmp 0x215e27
leaq 0xa0241(%rip), %rax     # 0x2b6068
movq %rax, 0x5c2cca(%rip)    # 0x7d8af8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_64_dispatcher
parasail_result_t* parasail_sw_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215e81
leaq 0x2a95cd(%rip), %rax    # 0x4bf44c
jmp 0x215eb0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215e95
leaq 0x1bab0d(%rip), %rax    # 0x3d09a0
jmp 0x215eb0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x215ea9
leaq 0x85319(%rip), %rax     # 0x29b1c0
jmp 0x215eb0
leaq 0xaacb4(%rip), %rax     # 0x2c0b64
movq %rax, 0x5c2c49(%rip)    # 0x7d8b00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_32_dispatcher
parasail_result_t* parasail_sw_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215f0a
leaq 0x2aab9c(%rip), %rax    # 0x4c0aa4
jmp 0x215f39
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215f1e
leaq 0x1bc1b0(%rip), %rax    # 0x3d20cc
jmp 0x215f39
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x215f32
leaq 0x85290(%rip), %rax     # 0x29b1c0
jmp 0x215f39
leaq 0xac7a7(%rip), %rax     # 0x2c26e0
movq %rax, 0x5c2bc8(%rip)    # 0x7d8b08
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_16_dispatcher
parasail_result_t* parasail_sw_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x215f93
leaq 0x2acc1b(%rip), %rax    # 0x4c2bac
jmp 0x215fc2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x215fa7
leaq 0x1bda8f(%rip), %rax    # 0x3d3a34
jmp 0x215fc2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x215fbb
leaq 0x85207(%rip), %rax     # 0x29b1c0
jmp 0x215fc2
leaq 0xae49e(%rip), %rax     # 0x2c4460
movq %rax, 0x5c2b47(%rip)    # 0x7d8b10
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_8_dispatcher
parasail_result_t* parasail_sw_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21601c
leaq 0x2afaba(%rip), %rax    # 0x4c5ad4
jmp 0x21604b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216030
leaq 0x1bf772(%rip), %rax    # 0x3d57a0
jmp 0x21604b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216044
leaq 0x8517e(%rip), %rax     # 0x29b1c0
jmp 0x21604b
leaq 0xb0a19(%rip), %rax     # 0x2c6a64
movq %rax, 0x5c2ac6(%rip)    # 0x7d8b18
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_diag_64_dispatcher
parasail_result_t* parasail_sw_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2160a5
leaq 0x2a02e5(%rip), %rax    # 0x4b6388
jmp 0x2160d4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2160b9
leaq 0x1b3271(%rip), %rax    # 0x3c9328
jmp 0x2160d4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2160cd
leaq 0x850f5(%rip), %rax     # 0x29b1c0
jmp 0x2160d4
leaq 0xa1f2c(%rip), %rax     # 0x2b8000
movq %rax, 0x5c2a45(%rip)    # 0x7d8b20
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_diag_32_dispatcher
parasail_result_t* parasail_sw_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21612e
leaq 0x2a1f38(%rip), %rax    # 0x4b8064
jmp 0x21615d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216142
leaq 0x1b4a64(%rip), %rax    # 0x3caba4
jmp 0x21615d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216156
leaq 0x8506c(%rip), %rax     # 0x29b1c0
jmp 0x21615d
leaq 0xa3bb3(%rip), %rax     # 0x2b9d10
movq %rax, 0x5c29c4(%rip)    # 0x7d8b28
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_diag_16_dispatcher
parasail_result_t* parasail_sw_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2161b7
leaq 0x2a4313(%rip), %rax    # 0x4ba4c8
jmp 0x2161e6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2161cb
leaq 0x1b65ab(%rip), %rax    # 0x3cc774
jmp 0x2161e6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2161df
leaq 0x84fe3(%rip), %rax     # 0x29b1c0
jmp 0x2161e6
leaq 0xa59aa(%rip), %rax     # 0x2bbb90
movq %rax, 0x5c2943(%rip)    # 0x7d8b30
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_diag_8_dispatcher
parasail_result_t* parasail_sw_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x216240
leaq 0x2a71de(%rip), %rax    # 0x4bd41c
jmp 0x21626f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216254
leaq 0x1b889a(%rip), %rax    # 0x3ceaec
jmp 0x21626f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216268
leaq 0x84f5a(%rip), %rax     # 0x29b1c0
jmp 0x21626f
leaq 0xa82dd(%rip), %rax     # 0x2be54c
movq %rax, 0x5c28c2(%rip)    # 0x7d8b38
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax