LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x2353aa
leaq 0x3330cd(%rip), %rax    # 0x568475
jmp 0x2353d0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2353be
leaq 0x229bca(%rip), %rax    # 0x45ef86
jmp 0x2353d0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2353ef
leaq 0x143317(%rip), %rax    # 0x3786e7
movq %rax, 0x56f549(%rip)    # 0x7a4920
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x235424
leaq 0x33684e(%rip), %rax    # 0x56bc70
jmp 0x23544a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235438
leaq 0x22ce44(%rip), %rax    # 0x46227a
jmp 0x23544a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x235469
leaq 0x146c64(%rip), %rax    # 0x37c0ae
movq %rax, 0x56f4d7(%rip)    # 0x7a4928
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x23549e
leaq 0x33a383(%rip), %rax    # 0x56f81f
jmp 0x2354c4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2354b2
leaq 0x230237(%rip), %rax    # 0x4656e7
jmp 0x2354c4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2354e3
leaq 0x14a4ad(%rip), %rax    # 0x37f971
movq %rax, 0x56f465(%rip)    # 0x7a4930
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x235518
leaq 0x33e1a2(%rip), %rax    # 0x5736b8
jmp 0x23553e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23552c
leaq 0x234068(%rip), %rax    # 0x469592
jmp 0x23553e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23555d
leaq 0x14e73e(%rip), %rax    # 0x383c7c
movq %rax, 0x56f3f3(%rip)    # 0x7a4938
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x235592
leaq 0x3413dd(%rip), %rax    # 0x57696d
jmp 0x2355b8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2355a6
leaq 0x236c7d(%rip), %rax    # 0x46c221
jmp 0x2355b8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2355d7
leaq 0x1516cc(%rip), %rax    # 0x386c84
movq %rax, 0x56f381(%rip)    # 0x7a4940
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x23560c
leaq 0x3432ea(%rip), %rax    # 0x5788f4
jmp 0x235632
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235620
leaq 0x2387cf(%rip), %rax    # 0x46dded
jmp 0x235632
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x235651
leaq 0x1534fc(%rip), %rax    # 0x388b2e
movq %rax, 0x56f30f(%rip)    # 0x7a4948
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x235686
leaq 0x344d2f(%rip), %rax    # 0x57a3b3
jmp 0x2356ac
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23569a
leaq 0x23a17e(%rip), %rax    # 0x46f816
jmp 0x2356ac
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2356cb
leaq 0x155033(%rip), %rax    # 0x38a6df
movq %rax, 0x56f29d(%rip)    # 0x7a4950
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x235700
leaq 0x346756(%rip), %rax    # 0x57be54
jmp 0x235726
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235714
leaq 0x23bb56(%rip), %rax    # 0x471268
jmp 0x235726
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x235745
leaq 0x156cc9(%rip), %rax    # 0x38c3ef
movq %rax, 0x56f22b(%rip)    # 0x7a4958
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x23577a
leaq 0x35843c(%rip), %rax    # 0x58dbb4
jmp 0x2357a0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23578e
leaq 0x248528(%rip), %rax    # 0x47dcb4
jmp 0x2357a0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2357bf
leaq 0x164b4d(%rip), %rax    # 0x39a2ed
movq %rax, 0x56f1b9(%rip)    # 0x7a4960
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2357f4
leaq 0x35a996(%rip), %rax    # 0x590188
jmp 0x23581a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235808
leaq 0x24a86b(%rip), %rax    # 0x480071
jmp 0x23581a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x235839
leaq 0x16723c(%rip), %rax    # 0x39ca56
movq %rax, 0x56f147(%rip)    # 0x7a4968
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x23586e
leaq 0x35ca86(%rip), %rax    # 0x5922f2
jmp 0x235894
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235882
leaq 0x24c8f8(%rip), %rax    # 0x482178
jmp 0x235894
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2358b3
leaq 0x169411(%rip), %rax    # 0x39eca5
movq %rax, 0x56f0d5(%rip)    # 0x7a4970
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2358e8
leaq 0x35eba4(%rip), %rax    # 0x59448a
jmp 0x23590e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2358fc
leaq 0x24e998(%rip), %rax    # 0x484292
jmp 0x23590e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23592d
leaq 0x16b7e1(%rip), %rax    # 0x3a10ef
movq %rax, 0x56f063(%rip)    # 0x7a4978
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x235e55
leaq 0x250740(%rip), %rax    # 0x486593
jmp 0x235e84
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235e69
leaq 0x16cf21(%rip), %rax    # 0x3a2d88
jmp 0x235e84
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x235e7d
leaq 0x64b4f(%rip), %rax     # 0x29a9ca
jmp 0x235e84
leaq 0x760f9(%rip), %rax     # 0x2abf7d
movq %rax, 0x56eaf5(%rip)    # 0x7a4980
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_O1/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 0x594f9c
testl %eax, %eax
je 0x235ede
leaq 0x2521fd(%rip), %rax    # 0x4880d9
jmp 0x235f0d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235ef2
leaq 0x16e6c3(%rip), %rax    # 0x3a45b3
jmp 0x235f0d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x235f06
leaq 0x64ac6(%rip), %rax     # 0x29a9ca
jmp 0x235f0d
leaq 0x77ad8(%rip), %rax     # 0x2ad9e5
movq %rax, 0x56ea74(%rip)    # 0x7a4988
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_O1/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 0x594f9c
testl %eax, %eax
je 0x235f67
leaq 0x253863(%rip), %rax    # 0x4897c8
jmp 0x235f96
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x235f7b
leaq 0x16fd0d(%rip), %rax    # 0x3a5c86
jmp 0x235f96
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x235f8f
leaq 0x64a3d(%rip), %rax     # 0x29a9ca
jmp 0x235f96
leaq 0x79228(%rip), %rax     # 0x2af1be
movq %rax, 0x56e9f3(%rip)    # 0x7a4990
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_O1/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 0x594f9c
testl %eax, %eax
je 0x235ff0
leaq 0x254ea0(%rip), %rax    # 0x48ae8e
jmp 0x23601f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236004
leaq 0x171346(%rip), %rax    # 0x3a7348
jmp 0x23601f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236018
leaq 0x649b4(%rip), %rax     # 0x29a9ca
jmp 0x23601f
leaq 0x7ab2c(%rip), %rax     # 0x2b0b4b
movq %rax, 0x56e972(%rip)    # 0x7a4998
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_O1/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 0x594f9c
testl %eax, %eax
je 0x236079
leaq 0x261519(%rip), %rax    # 0x497590
jmp 0x2360a8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23608d
leaq 0x17a8fe(%rip), %rax    # 0x3b0989
jmp 0x2360a8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2360a1
leaq 0x63aad(%rip), %rax     # 0x299b4c
jmp 0x2360a8
leaq 0x84f83(%rip), %rax     # 0x2bb02b
movq %rax, 0x56e8f1(%rip)    # 0x7a49a0
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_O1/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 0x594f9c
testl %eax, %eax
je 0x236102
leaq 0x262c51(%rip), %rax    # 0x498d51
jmp 0x236131
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236116
leaq 0x17beb1(%rip), %rax    # 0x3b1fc5
jmp 0x236131
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23612a
leaq 0x63a24(%rip), %rax     # 0x299b4c
jmp 0x236131
leaq 0x866c6(%rip), %rax     # 0x2bc7f7
movq %rax, 0x56e870(%rip)    # 0x7a49a8
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23618b
leaq 0x264076(%rip), %rax    # 0x49a1ff
jmp 0x2361ba
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23619f
leaq 0x17d2cd(%rip), %rax    # 0x3b346a
jmp 0x2361ba
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2361b3
leaq 0x6399b(%rip), %rax     # 0x299b4c
jmp 0x2361ba
leaq 0x87b88(%rip), %rax     # 0x2bdd42
movq %rax, 0x56e7ef(%rip)    # 0x7a49b0
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_O1/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 0x594f9c
testl %eax, %eax
je 0x236214
leaq 0x2654c5(%rip), %rax    # 0x49b6d7
jmp 0x236243
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236228
leaq 0x17e719(%rip), %rax    # 0x3b493f
jmp 0x236243
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23623c
leaq 0x63912(%rip), %rax     # 0x299b4c
jmp 0x236243
leaq 0x89233(%rip), %rax     # 0x2bf476
movq %rax, 0x56e76e(%rip)    # 0x7a49b8
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_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x23629d
leaq 0x256cb4(%rip), %rax    # 0x48cf4f
jmp 0x2362cc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2362b1
leaq 0x172bfb(%rip), %rax    # 0x3a8eaa
jmp 0x2362cc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2362c5
leaq 0x63889(%rip), %rax     # 0x299b4c
jmp 0x2362cc
leaq 0x7c78c(%rip), %rax     # 0x2b2a58
movq %rax, 0x56e6ed(%rip)    # 0x7a49c0
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_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236326
leaq 0x258c32(%rip), %rax    # 0x48ef56
jmp 0x236355
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23633a
leaq 0x174576(%rip), %rax    # 0x3aa8ae
jmp 0x236355
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23634e
leaq 0x63800(%rip), %rax     # 0x299b4c
jmp 0x236355
leaq 0x7e422(%rip), %rax     # 0x2b4777
movq %rax, 0x56e66c(%rip)    # 0x7a49c8
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