LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_rowcol_striped_profile_8_pointer = parasail_sg_qx_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_striped_profile_8_pointer = parasail_sg_qx_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_striped_profile_8_pointer = parasail_sg_qx_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_striped_profile_8_pointer = parasail_sg_qx_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_striped_profile_8_pointer = parasail_sg_qx_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x226f68
leaq 0x34c704(%rip), %rax    # 0x57366a
jmp 0x226f8e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x226f7c
leaq 0x2425ca(%rip), %rax    # 0x469544
jmp 0x226f8e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x226fad
leaq 0x15cca0(%rip), %rax    # 0x383c2e
movq %rax, 0x57cc83(%rip)    # 0x7a3c18
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_scan_profile_64_pointer = parasail_sg_qx_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_profile_64_pointer = parasail_sg_qx_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_profile_64_pointer = parasail_sg_qx_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_profile_64_pointer = parasail_sg_qx_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_profile_64_pointer = parasail_sg_qx_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x226fe2
leaq 0x34f93f(%rip), %rax    # 0x57691f
jmp 0x227008
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x226ff6
leaq 0x2451df(%rip), %rax    # 0x46c1d3
jmp 0x227008
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x227027
leaq 0x15fc2e(%rip), %rax    # 0x386c36
movq %rax, 0x57cc11(%rip)    # 0x7a3c20
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_scan_profile_32_pointer = parasail_sg_qx_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_profile_32_pointer = parasail_sg_qx_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_profile_32_pointer = parasail_sg_qx_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_profile_32_pointer = parasail_sg_qx_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_profile_32_pointer = parasail_sg_qx_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x22705c
leaq 0x35184c(%rip), %rax    # 0x5788a6
jmp 0x227082
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227070
leaq 0x246d31(%rip), %rax    # 0x46dd9f
jmp 0x227082
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2270a1
leaq 0x161a5e(%rip), %rax    # 0x388ae0
movq %rax, 0x57cb9f(%rip)    # 0x7a3c28
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_scan_profile_16_pointer = parasail_sg_qx_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_profile_16_pointer = parasail_sg_qx_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_profile_16_pointer = parasail_sg_qx_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_profile_16_pointer = parasail_sg_qx_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_profile_16_pointer = parasail_sg_qx_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x2270d6
leaq 0x353291(%rip), %rax    # 0x57a365
jmp 0x2270fc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2270ea
leaq 0x2486e0(%rip), %rax    # 0x46f7c8
jmp 0x2270fc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22711b
leaq 0x163595(%rip), %rax    # 0x38a691
movq %rax, 0x57cb2d(%rip)    # 0x7a3c30
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_scan_profile_8_pointer = parasail_sg_qx_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_profile_8_pointer = parasail_sg_qx_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_profile_8_pointer = parasail_sg_qx_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_profile_8_pointer = parasail_sg_qx_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_profile_8_pointer = parasail_sg_qx_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x227150
leaq 0x354cb8(%rip), %rax    # 0x57be06
jmp 0x227176
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227164
leaq 0x24a0b8(%rip), %rax    # 0x47121a
jmp 0x227176
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x227195
leaq 0x16522b(%rip), %rax    # 0x38c3a1
movq %rax, 0x57cabb(%rip)    # 0x7a3c38
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_striped_profile_64_pointer = parasail_sg_qx_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_profile_64_pointer = parasail_sg_qx_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_profile_64_pointer = parasail_sg_qx_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_profile_64_pointer = parasail_sg_qx_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_profile_64_pointer = parasail_sg_qx_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x2271ca
leaq 0x36699e(%rip), %rax    # 0x58db66
jmp 0x2271f0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2271de
leaq 0x256a8a(%rip), %rax    # 0x47dc66
jmp 0x2271f0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22720f
leaq 0x1730af(%rip), %rax    # 0x39a29f
movq %rax, 0x57ca49(%rip)    # 0x7a3c40
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_striped_profile_32_pointer = parasail_sg_qx_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_profile_32_pointer = parasail_sg_qx_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_profile_32_pointer = parasail_sg_qx_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_profile_32_pointer = parasail_sg_qx_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_profile_32_pointer = parasail_sg_qx_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x227244
leaq 0x368ef8(%rip), %rax    # 0x59013a
jmp 0x22726a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227258
leaq 0x258dcd(%rip), %rax    # 0x480023
jmp 0x22726a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x227289
leaq 0x17579e(%rip), %rax    # 0x39ca08
movq %rax, 0x57c9d7(%rip)    # 0x7a3c48
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_striped_profile_16_pointer = parasail_sg_qx_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_profile_16_pointer = parasail_sg_qx_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_profile_16_pointer = parasail_sg_qx_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_profile_16_pointer = parasail_sg_qx_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_profile_16_pointer = parasail_sg_qx_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x2272be
leaq 0x36afe8(%rip), %rax    # 0x5922a4
jmp 0x2272e4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2272d2
leaq 0x25ae5a(%rip), %rax    # 0x48212a
jmp 0x2272e4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x227303
leaq 0x177973(%rip), %rax    # 0x39ec57
movq %rax, 0x57c965(%rip)    # 0x7a3c50
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_trace_striped_profile_8_pointer = parasail_sg_qx_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_profile_8_pointer = parasail_sg_qx_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_profile_8_pointer = parasail_sg_qx_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_profile_8_pointer = parasail_sg_qx_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_profile_8_pointer = parasail_sg_qx_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x227338
leaq 0x36d106(%rip), %rax    # 0x59443c
jmp 0x22735e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22734c
leaq 0x25cefa(%rip), %rax    # 0x484244
jmp 0x22735e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22737d
leaq 0x179d43(%rip), %rax    # 0x3a10a1
movq %rax, 0x57c8f3(%rip)    # 0x7a3c58
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_scan_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_scan_64_pointer = parasail_sg_db_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_scan_64_pointer = parasail_sg_db_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_scan_64_pointer = parasail_sg_db_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_scan_64_pointer = parasail_sg_db_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_scan_64_pointer = parasail_sg_db_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x2278a5
leaq 0x25ec98(%rip), %rax    # 0x48653b
jmp 0x2278d4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2278b9
leaq 0x17b479(%rip), %rax    # 0x3a2d30
jmp 0x2278d4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2278cd
leaq 0x730a7(%rip), %rax     # 0x29a972
jmp 0x2278d4
leaq 0x84651(%rip), %rax     # 0x2abf25
movq %rax, 0x57c385(%rip)    # 0x7a3c60
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_db_dispatch.c
// Function: parasail_sg_db_scan_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_scan_32_pointer = parasail_sg_db_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_scan_32_pointer = parasail_sg_db_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_scan_32_pointer = parasail_sg_db_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_scan_32_pointer = parasail_sg_db_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_scan_32_pointer = parasail_sg_db_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_scan_32_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x22792e
leaq 0x260755(%rip), %rax    # 0x488081
jmp 0x22795d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227942
leaq 0x17cc1b(%rip), %rax    # 0x3a455b
jmp 0x22795d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227956
leaq 0x7301e(%rip), %rax     # 0x29a972
jmp 0x22795d
leaq 0x86030(%rip), %rax     # 0x2ad98d
movq %rax, 0x57c304(%rip)    # 0x7a3c68
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_db_dispatch.c
// Function: parasail_sg_db_scan_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_scan_16_pointer = parasail_sg_db_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_scan_16_pointer = parasail_sg_db_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_scan_16_pointer = parasail_sg_db_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_scan_16_pointer = parasail_sg_db_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_scan_16_pointer = parasail_sg_db_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_scan_16_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x2279b7
leaq 0x261dbb(%rip), %rax    # 0x489770
jmp 0x2279e6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2279cb
leaq 0x17e265(%rip), %rax    # 0x3a5c2e
jmp 0x2279e6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2279df
leaq 0x72f95(%rip), %rax     # 0x29a972
jmp 0x2279e6
leaq 0x87780(%rip), %rax     # 0x2af166
movq %rax, 0x57c283(%rip)    # 0x7a3c70
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_db_dispatch.c
// Function: parasail_sg_db_scan_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_scan_8_pointer = parasail_sg_db_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_scan_8_pointer = parasail_sg_db_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_scan_8_pointer = parasail_sg_db_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_scan_8_pointer = parasail_sg_db_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_scan_8_pointer = parasail_sg_db_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_scan_8_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x227a40
leaq 0x2633f8(%rip), %rax    # 0x48ae36
jmp 0x227a6f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227a54
leaq 0x17f89e(%rip), %rax    # 0x3a72f0
jmp 0x227a6f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227a68
leaq 0x72f0c(%rip), %rax     # 0x29a972
jmp 0x227a6f
leaq 0x89084(%rip), %rax     # 0x2b0af3
movq %rax, 0x57c202(%rip)    # 0x7a3c78
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_db_dispatch.c
// Function: parasail_sg_db_striped_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_striped_64_pointer = parasail_sg_db_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_striped_64_pointer = parasail_sg_db_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_striped_64_pointer = parasail_sg_db_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_striped_64_pointer = parasail_sg_db_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_striped_64_pointer = parasail_sg_db_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_striped_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x227ac9
leaq 0x26fa71(%rip), %rax    # 0x497538
jmp 0x227af8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227add
leaq 0x188e56(%rip), %rax    # 0x3b0931
jmp 0x227af8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227af1
leaq 0x72005(%rip), %rax     # 0x299af4
jmp 0x227af8
leaq 0x934db(%rip), %rax     # 0x2bafd3
movq %rax, 0x57c181(%rip)    # 0x7a3c80
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_db_dispatch.c
// Function: parasail_sg_db_striped_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_striped_32_pointer = parasail_sg_db_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_striped_32_pointer = parasail_sg_db_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_striped_32_pointer = parasail_sg_db_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_striped_32_pointer = parasail_sg_db_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_striped_32_pointer = parasail_sg_db_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_striped_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x227b52
leaq 0x2711a9(%rip), %rax    # 0x498cf9
jmp 0x227b81
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227b66
leaq 0x18a409(%rip), %rax    # 0x3b1f6d
jmp 0x227b81
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227b7a
leaq 0x71f7c(%rip), %rax     # 0x299af4
jmp 0x227b81
leaq 0x94c1e(%rip), %rax     # 0x2bc79f
movq %rax, 0x57c100(%rip)    # 0x7a3c88
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_db_dispatch.c
// Function: parasail_sg_db_striped_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_striped_16_pointer = parasail_sg_db_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_striped_16_pointer = parasail_sg_db_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_striped_16_pointer = parasail_sg_db_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_striped_16_pointer = parasail_sg_db_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_striped_16_pointer = parasail_sg_db_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_striped_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x227bdb
leaq 0x2725ce(%rip), %rax    # 0x49a1a7
jmp 0x227c0a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227bef
leaq 0x18b825(%rip), %rax    # 0x3b3412
jmp 0x227c0a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227c03
leaq 0x71ef3(%rip), %rax     # 0x299af4
jmp 0x227c0a
leaq 0x960e0(%rip), %rax     # 0x2bdcea
movq %rax, 0x57c07f(%rip)    # 0x7a3c90
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_db_dispatch.c
// Function: parasail_sg_db_striped_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_striped_8_pointer = parasail_sg_db_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_striped_8_pointer = parasail_sg_db_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_striped_8_pointer = parasail_sg_db_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_striped_8_pointer = parasail_sg_db_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_striped_8_pointer = parasail_sg_db_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_striped_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x227c64
leaq 0x273a1d(%rip), %rax    # 0x49b67f
jmp 0x227c93
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227c78
leaq 0x18cc71(%rip), %rax    # 0x3b48e7
jmp 0x227c93
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227c8c
leaq 0x71e6a(%rip), %rax     # 0x299af4
jmp 0x227c93
leaq 0x9778b(%rip), %rax     # 0x2bf41e
movq %rax, 0x57bffe(%rip)    # 0x7a3c98
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_db_dispatch.c
// Function: parasail_sg_db_diag_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_diag_64_pointer = parasail_sg_db_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_diag_64_pointer = parasail_sg_db_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_diag_64_pointer = parasail_sg_db_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_diag_64_pointer = parasail_sg_db_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_diag_64_pointer = parasail_sg_db_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_diag_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x227ced
leaq 0x26520c(%rip), %rax    # 0x48cef7
jmp 0x227d1c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227d01
leaq 0x181153(%rip), %rax    # 0x3a8e52
jmp 0x227d1c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227d15
leaq 0x71de1(%rip), %rax     # 0x299af4
jmp 0x227d1c
leaq 0x8ace4(%rip), %rax     # 0x2b2a00
movq %rax, 0x57bf7d(%rip)    # 0x7a3ca0
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_db_dispatch.c
// Function: parasail_sg_db_diag_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_diag_32_pointer = parasail_sg_db_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_diag_32_pointer = parasail_sg_db_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_diag_32_pointer = parasail_sg_db_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_diag_32_pointer = parasail_sg_db_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_diag_32_pointer = parasail_sg_db_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_diag_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x227d76
leaq 0x26718a(%rip), %rax    # 0x48eefe
jmp 0x227da5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227d8a
leaq 0x182ace(%rip), %rax    # 0x3aa856
jmp 0x227da5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227d9e
leaq 0x71d58(%rip), %rax     # 0x299af4
jmp 0x227da5
leaq 0x8c97a(%rip), %rax     # 0x2b471f
movq %rax, 0x57befc(%rip)    # 0x7a3ca8
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_db_dispatch.c
// Function: parasail_sg_db_diag_16_dispatcher
parasail_result_t* parasail_sg_db_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_diag_16_pointer = parasail_sg_db_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_diag_16_pointer = parasail_sg_db_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_diag_16_pointer = parasail_sg_db_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_diag_16_pointer = parasail_sg_db_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_diag_16_pointer = parasail_sg_db_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_diag_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x227dff
leaq 0x2695cb(%rip), %rax    # 0x4913c8
jmp 0x227e2e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227e13
leaq 0x18468d(%rip), %rax    # 0x3ac49e
jmp 0x227e2e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227e27
leaq 0x71ccf(%rip), %rax     # 0x299af4
jmp 0x227e2e
leaq 0x8e750(%rip), %rax     # 0x2b657e
movq %rax, 0x57be7b(%rip)    # 0x7a3cb0
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_db_dispatch.c
// Function: parasail_sg_db_diag_8_dispatcher
parasail_result_t* parasail_sg_db_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_diag_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x227e88
leaq 0x26cbf8(%rip), %rax    # 0x494a7e
jmp 0x227eb7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227e9c
leaq 0x186aae(%rip), %rax    # 0x3ae948
jmp 0x227eb7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227eb0
leaq 0x71c46(%rip), %rax     # 0x299af4
jmp 0x227eb7
leaq 0x90f49(%rip), %rax     # 0x2b8e00
movq %rax, 0x57bdfa(%rip)    # 0x7a3cb8
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_db_dispatch.c
// Function: parasail_sg_db_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_db_stats_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_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_stats_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 0x227f11
leaq 0x2769ac(%rip), %rax    # 0x49e8bb
jmp 0x227f40
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227f25
leaq 0x18fb43(%rip), %rax    # 0x3b7a66
jmp 0x227f40
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227f39
leaq 0x72a3b(%rip), %rax     # 0x29a972
jmp 0x227f40
leaq 0x9a488(%rip), %rax     # 0x2c23c8
movq %rax, 0x57bd79(%rip)    # 0x7a3cc0
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