LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_dx_stats_rowcol_scan_profile_16_pointer = parasail_sg_dx_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_profile_16_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_profile_16_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_profile_16_pointer = parasail_sg_dx_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_profile_16_pointer = parasail_sg_dx_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_rowcol_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d7f0a
leaq 0x34376a(%rip), %rax    # 0x51b672
jmp 0x1d7f30
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7f1e
leaq 0x239152(%rip), %rax    # 0x41106e
jmp 0x1d7f30
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7f4f
leaq 0x13e8be(%rip), %rax    # 0x3167ee
movq %rax, 0x5659d9(%rip)    # 0x73d910
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_dx_stats_rowcol_scan_profile_8_pointer = parasail_sg_dx_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_profile_8_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_profile_8_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_profile_8_pointer = parasail_sg_dx_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_profile_8_pointer = parasail_sg_dx_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_rowcol_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d7f84
leaq 0x3477a1(%rip), %rax    # 0x51f723
jmp 0x1d7faa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7f98
leaq 0x23cdf4(%rip), %rax    # 0x414d8a
jmp 0x1d7faa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7fc9
leaq 0x142af1(%rip), %rax    # 0x31aa9b
movq %rax, 0x565967(%rip)    # 0x73d918
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_dx_stats_rowcol_striped_profile_64_pointer = parasail_sg_dx_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_profile_64_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_profile_64_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_profile_64_pointer = parasail_sg_dx_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_profile_64_pointer = parasail_sg_dx_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_rowcol_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d7ffe
leaq 0x361077(%rip), %rax    # 0x539073
jmp 0x1d8024
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8012
leaq 0x25255d(%rip), %rax    # 0x42a56d
jmp 0x1d8024
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d8043
leaq 0x15b157(%rip), %rax    # 0x33317b
movq %rax, 0x5658f5(%rip)    # 0x73d920
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_profile_32_pointer = parasail_sg_dx_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_profile_32_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_profile_32_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_profile_32_pointer = parasail_sg_dx_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_profile_32_pointer = parasail_sg_dx_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d8078
leaq 0x364b27(%rip), %rax    # 0x53cb9d
jmp 0x1d809e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d808c
leaq 0x255f1a(%rip), %rax    # 0x42dfa4
jmp 0x1d809e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d80bd
leaq 0x15f37d(%rip), %rax    # 0x33741b
movq %rax, 0x565883(%rip)    # 0x73d928
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_profile_16_pointer = parasail_sg_dx_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_profile_16_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_profile_16_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_profile_16_pointer = parasail_sg_dx_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_profile_16_pointer = parasail_sg_dx_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d80f2
leaq 0x3684c8(%rip), %rax    # 0x5405b8
jmp 0x1d8118
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8106
leaq 0x2596ec(%rip), %rax    # 0x4317f0
jmp 0x1d8118
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d8137
leaq 0x163001(%rip), %rax    # 0x33b119
movq %rax, 0x565811(%rip)    # 0x73d930
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_profile_8_pointer = parasail_sg_dx_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_profile_8_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_profile_8_pointer = parasail_sg_dx_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_profile_8_pointer = parasail_sg_dx_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_profile_8_pointer = parasail_sg_dx_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d816c
leaq 0x36c380(%rip), %rax    # 0x5444ea
jmp 0x1d8192
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8180
leaq 0x25d18b(%rip), %rax    # 0x435309
jmp 0x1d8192
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d81b1
leaq 0x166f79(%rip), %rax    # 0x33f10b
movq %rax, 0x56579f(%rip)    # 0x73d938
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_scan_profile_64_pointer = parasail_sg_dx_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_profile_64_pointer = parasail_sg_dx_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_profile_64_pointer = parasail_sg_dx_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_profile_64_pointer = parasail_sg_dx_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_profile_64_pointer = parasail_sg_dx_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d81e6
leaq 0x36f331(%rip), %rax    # 0x547515
jmp 0x1d820c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d81fa
leaq 0x25ff0a(%rip), %rax    # 0x438102
jmp 0x1d820c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d822b
leaq 0x16a4b8(%rip), %rax    # 0x3426c4
movq %rax, 0x56572d(%rip)    # 0x73d940
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_scan_profile_32_pointer = parasail_sg_dx_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_profile_32_pointer = parasail_sg_dx_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_profile_32_pointer = parasail_sg_dx_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_profile_32_pointer = parasail_sg_dx_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_profile_32_pointer = parasail_sg_dx_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d8260
leaq 0x371206(%rip), %rax    # 0x549464
jmp 0x1d8286
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8274
leaq 0x261daa(%rip), %rax    # 0x43a01c
jmp 0x1d8286
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d82a5
leaq 0x16c837(%rip), %rax    # 0x344abd
movq %rax, 0x5656bb(%rip)    # 0x73d948
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_scan_profile_16_pointer = parasail_sg_dx_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_profile_16_pointer = parasail_sg_dx_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_profile_16_pointer = parasail_sg_dx_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_profile_16_pointer = parasail_sg_dx_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_profile_16_pointer = parasail_sg_dx_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d82da
leaq 0x372f9d(%rip), %rax    # 0x54b275
jmp 0x1d8300
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d82ee
leaq 0x263bd3(%rip), %rax    # 0x43bebf
jmp 0x1d8300
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d831f
leaq 0x16e7c8(%rip), %rax    # 0x346ac8
movq %rax, 0x565649(%rip)    # 0x73d950
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_scan_profile_8_pointer = parasail_sg_dx_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_profile_8_pointer = parasail_sg_dx_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_profile_8_pointer = parasail_sg_dx_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_profile_8_pointer = parasail_sg_dx_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_profile_8_pointer = parasail_sg_dx_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d8354
leaq 0x374d10(%rip), %rax    # 0x54d062
jmp 0x1d837a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8368
leaq 0x2659f5(%rip), %rax    # 0x43dd5b
jmp 0x1d837a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d8399
leaq 0x1708e9(%rip), %rax    # 0x348c63
movq %rax, 0x5655d7(%rip)    # 0x73d958
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_striped_profile_64_pointer = parasail_sg_dx_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_profile_64_pointer = parasail_sg_dx_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_profile_64_pointer = parasail_sg_dx_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_profile_64_pointer = parasail_sg_dx_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_profile_64_pointer = parasail_sg_dx_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d83ce
leaq 0x386fd7(%rip), %rax    # 0x55f3a3
jmp 0x1d83f4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d83e2
leaq 0x273556(%rip), %rax    # 0x44b936
jmp 0x1d83f4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d8413
leaq 0x17fe59(%rip), %rax    # 0x35824d
movq %rax, 0x565565(%rip)    # 0x73d960
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_striped_profile_32_pointer = parasail_sg_dx_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_profile_32_pointer = parasail_sg_dx_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_profile_32_pointer = parasail_sg_dx_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_profile_32_pointer = parasail_sg_dx_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_profile_32_pointer = parasail_sg_dx_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d8448
leaq 0x389735(%rip), %rax    # 0x561b7b
jmp 0x1d846e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d845c
leaq 0x275c60(%rip), %rax    # 0x44e0ba
jmp 0x1d846e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d848d
leaq 0x182c0b(%rip), %rax    # 0x35b079
movq %rax, 0x5654f3(%rip)    # 0x73d968
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_striped_profile_16_pointer = parasail_sg_dx_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_profile_16_pointer = parasail_sg_dx_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_profile_16_pointer = parasail_sg_dx_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_profile_16_pointer = parasail_sg_dx_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_profile_16_pointer = parasail_sg_dx_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d84c2
leaq 0x38bc23(%rip), %rax    # 0x5640e3
jmp 0x1d84e8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d84d6
leaq 0x27813b(%rip), %rax    # 0x45060f
jmp 0x1d84e8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d8507
leaq 0x18528a(%rip), %rax    # 0x35d772
movq %rax, 0x565481(%rip)    # 0x73d970
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_trace_striped_profile_8_pointer = parasail_sg_dx_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_profile_8_pointer = parasail_sg_dx_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_profile_8_pointer = parasail_sg_dx_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_profile_8_pointer = parasail_sg_dx_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_profile_8_pointer = parasail_sg_dx_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x5672cf
testl %eax, %eax
je 0x1d853c
leaq 0x38e0fd(%rip), %rax    # 0x566637
jmp 0x1d8562
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8550
leaq 0x27a64d(%rip), %rax    # 0x452b9b
jmp 0x1d8562
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d8581
leaq 0x187b45(%rip), %rax    # 0x3600a7
movq %rax, 0x56540f(%rip)    # 0x73d978
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_scan_64_pointer = parasail_sg_qb_de_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_64_pointer = parasail_sg_qb_de_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_64_pointer = parasail_sg_qb_de_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_64_pointer = parasail_sg_qb_de_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_64_pointer = parasail_sg_qb_de_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_scan_64_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8aa9
leaq 0x27c371(%rip), %rax    # 0x454e18
jmp 0x1d8ad8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8abd
leaq 0x189680(%rip), %rax    # 0x36213b
jmp 0x1d8ad8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8ad1
leaq 0x64e89(%rip), %rax     # 0x23d958
jmp 0x1d8ad8
leaq 0x785f2(%rip), %rax     # 0x2510ca
movq %rax, 0x564ea1(%rip)    # 0x73d980
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_scan_32_pointer = parasail_sg_qb_de_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_32_pointer = parasail_sg_qb_de_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_32_pointer = parasail_sg_qb_de_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_32_pointer = parasail_sg_qb_de_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_32_pointer = parasail_sg_qb_de_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_scan_32_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8b32
leaq 0x27df5d(%rip), %rax    # 0x456a8d
jmp 0x1d8b61
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8b46
leaq 0x18b18c(%rip), %rax    # 0x363cd0
jmp 0x1d8b61
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8b5a
leaq 0x64e00(%rip), %rax     # 0x23d958
jmp 0x1d8b61
leaq 0x7a578(%rip), %rax     # 0x2530d9
movq %rax, 0x564e20(%rip)    # 0x73d988
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_scan_16_pointer = parasail_sg_qb_de_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_16_pointer = parasail_sg_qb_de_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_16_pointer = parasail_sg_qb_de_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_16_pointer = parasail_sg_qb_de_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_16_pointer = parasail_sg_qb_de_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_scan_16_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8bbb
leaq 0x27fa50(%rip), %rax    # 0x458609
jmp 0x1d8bea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8bcf
leaq 0x18cc8e(%rip), %rax    # 0x36585b
jmp 0x1d8bea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8be3
leaq 0x64d77(%rip), %rax     # 0x23d958
jmp 0x1d8bea
leaq 0x7c1eb(%rip), %rax     # 0x254dd5
movq %rax, 0x564d9f(%rip)    # 0x73d990
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_scan_8_pointer = parasail_sg_qb_de_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_8_pointer = parasail_sg_qb_de_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_8_pointer = parasail_sg_qb_de_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_8_pointer = parasail_sg_qb_de_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_8_pointer = parasail_sg_qb_de_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_scan_8_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8c44
leaq 0x281534(%rip), %rax    # 0x45a176
jmp 0x1d8c73
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8c58
leaq 0x18e799(%rip), %rax    # 0x3673ef
jmp 0x1d8c73
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8c6c
leaq 0x64cee(%rip), %rax     # 0x23d958
jmp 0x1d8c73
leaq 0x7dff3(%rip), %rax     # 0x256c66
movq %rax, 0x564d1e(%rip)    # 0x73d998
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_striped_64_pointer = parasail_sg_qb_de_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_64_pointer = parasail_sg_qb_de_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_64_pointer = parasail_sg_qb_de_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_64_pointer = parasail_sg_qb_de_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_64_pointer = parasail_sg_qb_de_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_striped_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8ccd
leaq 0x28d10f(%rip), %rax    # 0x465dda
jmp 0x1d8cfc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8ce1
leaq 0x1983bd(%rip), %rax    # 0x37109c
jmp 0x1d8cfc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8cf5
leaq 0x63bf7(%rip), %rax     # 0x23c8ea
jmp 0x1d8cfc
leaq 0x898ee(%rip), %rax     # 0x2625ea
movq %rax, 0x564c9d(%rip)    # 0x73d9a0
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_striped_32_pointer = parasail_sg_qb_de_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_32_pointer = parasail_sg_qb_de_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_32_pointer = parasail_sg_qb_de_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_32_pointer = parasail_sg_qb_de_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_32_pointer = parasail_sg_qb_de_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_striped_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8d56
leaq 0x28eb00(%rip), %rax    # 0x467854
jmp 0x1d8d85
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8d6a
leaq 0x199d23(%rip), %rax    # 0x372a8b
jmp 0x1d8d85
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8d7e
leaq 0x63b6e(%rip), %rax     # 0x23c8ea
jmp 0x1d8d85
leaq 0x8b6bb(%rip), %rax     # 0x264440
movq %rax, 0x564c1c(%rip)    # 0x73d9a8
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_striped_16_pointer = parasail_sg_qb_de_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_16_pointer = parasail_sg_qb_de_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_16_pointer = parasail_sg_qb_de_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_16_pointer = parasail_sg_qb_de_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_16_pointer = parasail_sg_qb_de_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_striped_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8ddf
leaq 0x29040d(%rip), %rax    # 0x4691ea
jmp 0x1d8e0e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8df3
leaq 0x19b607(%rip), %rax    # 0x3743f8
jmp 0x1d8e0e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8e07
leaq 0x63ae5(%rip), %rax     # 0x23c8ea
jmp 0x1d8e0e
leaq 0x8d09d(%rip), %rax     # 0x265eab
movq %rax, 0x564b9b(%rip)    # 0x73d9b0
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_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_striped_8_pointer = parasail_sg_qb_de_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_8_pointer = parasail_sg_qb_de_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_8_pointer = parasail_sg_qb_de_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_8_pointer = parasail_sg_qb_de_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_8_pointer = parasail_sg_qb_de_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_striped_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x5672cf
testl %eax, %eax
je 0x1d8e68
leaq 0x291d10(%rip), %rax    # 0x46ab76
jmp 0x1d8e97
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8e7c
leaq 0x19cedb(%rip), %rax    # 0x375d55
jmp 0x1d8e97
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8e90
leaq 0x63a5c(%rip), %rax     # 0x23c8ea
jmp 0x1d8e97
leaq 0x8ec78(%rip), %rax     # 0x267b0f
movq %rax, 0x564b1a(%rip)    # 0x73d9b8
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