LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21d3e6
leaq 0x32c5c5(%rip), %rax    # 0x5499a9
jmp 0x21d40c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d3fa
leaq 0x22823e(%rip), %rax    # 0x445636
jmp 0x21d40c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d42b
leaq 0x13f875(%rip), %rax    # 0x35cc81
movq %rax, 0x585f1d(%rip)    # 0x7a3330
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_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21d460
leaq 0x330646(%rip), %rax    # 0x54daa4
jmp 0x21d486
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d474
leaq 0x22c29b(%rip), %rax    # 0x44970d
jmp 0x21d486
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d4a5
leaq 0x143e85(%rip), %rax    # 0x36130b
movq %rax, 0x585eab(%rip)    # 0x7a3338
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_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d4da
leaq 0x34af1b(%rip), %rax    # 0x5683f3
jmp 0x21d500
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d4ee
leaq 0x241a18(%rip), %rax    # 0x45ef04
jmp 0x21d500
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d51f
leaq 0x15b165(%rip), %rax    # 0x378665
movq %rax, 0x585e39(%rip)    # 0x7a3340
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_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d554
leaq 0x34e69c(%rip), %rax    # 0x56bbee
jmp 0x21d57a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d568
leaq 0x244c92(%rip), %rax    # 0x4621f8
jmp 0x21d57a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d599
leaq 0x15eab2(%rip), %rax    # 0x37c02c
movq %rax, 0x585dc7(%rip)    # 0x7a3348
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_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d5ce
leaq 0x3521d1(%rip), %rax    # 0x56f79d
jmp 0x21d5f4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d5e2
leaq 0x248085(%rip), %rax    # 0x465665
jmp 0x21d5f4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d613
leaq 0x1622fb(%rip), %rax    # 0x37f8ef
movq %rax, 0x585d55(%rip)    # 0x7a3350
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_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d648
leaq 0x355ff0(%rip), %rax    # 0x573636
jmp 0x21d66e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d65c
leaq 0x24beb6(%rip), %rax    # 0x469510
jmp 0x21d66e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d68d
leaq 0x16658c(%rip), %rax    # 0x383bfa
movq %rax, 0x585ce3(%rip)    # 0x7a3358
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_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d6c2
leaq 0x35922b(%rip), %rax    # 0x5768eb
jmp 0x21d6e8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d6d6
leaq 0x24eacb(%rip), %rax    # 0x46c19f
jmp 0x21d6e8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d707
leaq 0x16951a(%rip), %rax    # 0x386c02
movq %rax, 0x585c71(%rip)    # 0x7a3360
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_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d73c
leaq 0x35b138(%rip), %rax    # 0x578872
jmp 0x21d762
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d750
leaq 0x25061d(%rip), %rax    # 0x46dd6b
jmp 0x21d762
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d781
leaq 0x16b34a(%rip), %rax    # 0x388aac
movq %rax, 0x585bff(%rip)    # 0x7a3368
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_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d7b6
leaq 0x35cb7d(%rip), %rax    # 0x57a331
jmp 0x21d7dc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d7ca
leaq 0x251fcc(%rip), %rax    # 0x46f794
jmp 0x21d7dc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d7fb
leaq 0x16ce81(%rip), %rax    # 0x38a65d
movq %rax, 0x585b8d(%rip)    # 0x7a3370
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_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d830
leaq 0x35e5a4(%rip), %rax    # 0x57bdd2
jmp 0x21d856
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d844
leaq 0x2539a4(%rip), %rax    # 0x4711e6
jmp 0x21d856
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d875
leaq 0x16eb17(%rip), %rax    # 0x38c36d
movq %rax, 0x585b1b(%rip)    # 0x7a3378
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_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d8aa
leaq 0x37028a(%rip), %rax    # 0x58db32
jmp 0x21d8d0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d8be
leaq 0x260376(%rip), %rax    # 0x47dc32
jmp 0x21d8d0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d8ef
leaq 0x17c99b(%rip), %rax    # 0x39a26b
movq %rax, 0x585aa9(%rip)    # 0x7a3380
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_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d924
leaq 0x3727e4(%rip), %rax    # 0x590106
jmp 0x21d94a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d938
leaq 0x2626b9(%rip), %rax    # 0x47ffef
jmp 0x21d94a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d969
leaq 0x17f08a(%rip), %rax    # 0x39c9d4
movq %rax, 0x585a37(%rip)    # 0x7a3388
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_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21d99e
leaq 0x3748d4(%rip), %rax    # 0x592270
jmp 0x21d9c4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21d9b2
leaq 0x264746(%rip), %rax    # 0x4820f6
jmp 0x21d9c4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21d9e3
leaq 0x18125f(%rip), %rax    # 0x39ec23
movq %rax, 0x5859c5(%rip)    # 0x7a3390
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_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x21da18
leaq 0x3769f2(%rip), %rax    # 0x594408
jmp 0x21da3e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21da2c
leaq 0x2667e6(%rip), %rax    # 0x484210
jmp 0x21da3e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21da5d
leaq 0x18362f(%rip), %rax    # 0x3a106d
movq %rax, 0x585953(%rip)    # 0x7a3398
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_64_pointer = parasail_sg_qe_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21df85
leaq 0x26857b(%rip), %rax    # 0x4864fe
jmp 0x21dfb4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21df99
leaq 0x184d5c(%rip), %rax    # 0x3a2cf3
jmp 0x21dfb4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21dfad
leaq 0x7c98a(%rip), %rax     # 0x29a935
jmp 0x21dfb4
leaq 0x8df34(%rip), %rax     # 0x2abee8
movq %rax, 0x5853e5(%rip)    # 0x7a33a0
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_32_pointer = parasail_sg_qe_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21e00e
leaq 0x26a038(%rip), %rax    # 0x488044
jmp 0x21e03d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e022
leaq 0x1864fe(%rip), %rax    # 0x3a451e
jmp 0x21e03d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e036
leaq 0x7c901(%rip), %rax     # 0x29a935
jmp 0x21e03d
leaq 0x8f913(%rip), %rax     # 0x2ad950
movq %rax, 0x585364(%rip)    # 0x7a33a8
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_16_pointer = parasail_sg_qe_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21e097
leaq 0x26b69e(%rip), %rax    # 0x489733
jmp 0x21e0c6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e0ab
leaq 0x187b48(%rip), %rax    # 0x3a5bf1
jmp 0x21e0c6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e0bf
leaq 0x7c878(%rip), %rax     # 0x29a935
jmp 0x21e0c6
leaq 0x91063(%rip), %rax     # 0x2af129
movq %rax, 0x5852e3(%rip)    # 0x7a33b0
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_8_pointer = parasail_sg_qe_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21e120
leaq 0x26ccdb(%rip), %rax    # 0x48adf9
jmp 0x21e14f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e134
leaq 0x189181(%rip), %rax    # 0x3a72b3
jmp 0x21e14f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e148
leaq 0x7c7ef(%rip), %rax     # 0x29a935
jmp 0x21e14f
leaq 0x92967(%rip), %rax     # 0x2b0ab6
movq %rax, 0x585262(%rip)    # 0x7a33b8
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_64_pointer = parasail_sg_qe_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e1a9
leaq 0x279354(%rip), %rax    # 0x4974fb
jmp 0x21e1d8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e1bd
leaq 0x192739(%rip), %rax    # 0x3b08f4
jmp 0x21e1d8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e1d1
leaq 0x7b8e8(%rip), %rax     # 0x299ab7
jmp 0x21e1d8
leaq 0x9cdbe(%rip), %rax     # 0x2baf96
movq %rax, 0x5851e1(%rip)    # 0x7a33c0
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_32_pointer = parasail_sg_qe_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e232
leaq 0x27aa8c(%rip), %rax    # 0x498cbc
jmp 0x21e261
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e246
leaq 0x193cec(%rip), %rax    # 0x3b1f30
jmp 0x21e261
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e25a
leaq 0x7b85f(%rip), %rax     # 0x299ab7
jmp 0x21e261
leaq 0x9e501(%rip), %rax     # 0x2bc762
movq %rax, 0x585160(%rip)    # 0x7a33c8
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_16_pointer = parasail_sg_qe_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e2bb
leaq 0x27beb1(%rip), %rax    # 0x49a16a
jmp 0x21e2ea
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e2cf
leaq 0x195108(%rip), %rax    # 0x3b33d5
jmp 0x21e2ea
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e2e3
leaq 0x7b7d6(%rip), %rax     # 0x299ab7
jmp 0x21e2ea
leaq 0x9f9c3(%rip), %rax     # 0x2bdcad
movq %rax, 0x5850df(%rip)    # 0x7a33d0
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_8_pointer = parasail_sg_qe_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e344
leaq 0x27d300(%rip), %rax    # 0x49b642
jmp 0x21e373
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e358
leaq 0x196554(%rip), %rax    # 0x3b48aa
jmp 0x21e373
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e36c
leaq 0x7b74d(%rip), %rax     # 0x299ab7
jmp 0x21e373
leaq 0xa106e(%rip), %rax     # 0x2bf3e1
movq %rax, 0x58505e(%rip)    # 0x7a33d8
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