LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_trace_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f1276
leaq 0xa95be3(%rip), %rax    # 0xc86e50
movq %rax, 0xc37584(%rip)    # 0xe287f8
jmp 0x1f12bc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f1292
leaq 0x68a8e7(%rip), %rax    # 0x87bb70
movq %rax, 0xc37568(%rip)    # 0xe287f8
jmp 0x1f12ba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f12ae
leaq 0x3a236b(%rip), %rax    # 0x593610
movq %rax, 0xc3754c(%rip)    # 0xe287f8
jmp 0x1f12b8
movq $0x0, -0x8(%rbp)
jmp 0x1f12db
jmp 0x1f12ba
jmp 0x1f12bc
movq 0xc37535(%rip), %rax    # 0xe287f8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_64_pointer = parasail_sg_qx_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f3b6e
leaq 0x68f59b(%rip), %rax    # 0x883100
movq %rax, 0xc34c94(%rip)    # 0xe28800
jmp 0x1f3bb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f3b8a
leaq 0x3a666f(%rip), %rax    # 0x59a1f0
movq %rax, 0xc34c78(%rip)    # 0xe28800
jmp 0x1f3bb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f3ba6
leaq 0xcc713(%rip), %rax     # 0x2c02b0
movq %rax, 0xc34c5c(%rip)    # 0xe28800
jmp 0x1f3bb4
leaq 0xa5763(%rip), %rax     # 0x299310
movq %rax, 0xc34c4c(%rip)    # 0xe28800
jmp 0x1f3bb6
jmp 0x1f3bb8
movq 0xc34c41(%rip), %rax    # 0xe28800
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_32_pointer = parasail_sg_qx_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f3c2e
leaq 0x6959bb(%rip), %rax    # 0x8895e0
movq %rax, 0xc34bdc(%rip)    # 0xe28808
jmp 0x1f3c78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f3c4a
leaq 0x3ab82f(%rip), %rax    # 0x59f470
movq %rax, 0xc34bc0(%rip)    # 0xe28808
jmp 0x1f3c76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f3c66
leaq 0xd1ab3(%rip), %rax     # 0x2c5710
movq %rax, 0xc34ba4(%rip)    # 0xe28808
jmp 0x1f3c74
leaq 0xa56a3(%rip), %rax     # 0x299310
movq %rax, 0xc34b94(%rip)    # 0xe28808
jmp 0x1f3c76
jmp 0x1f3c78
movq 0xc34b89(%rip), %rax    # 0xe28808
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_16_pointer = parasail_sg_qx_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f3cee
leaq 0x69cc3b(%rip), %rax    # 0x890920
movq %rax, 0xc34b24(%rip)    # 0xe28810
jmp 0x1f3d38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f3d0a
leaq 0x3b0eef(%rip), %rax    # 0x5a4bf0
movq %rax, 0xc34b08(%rip)    # 0xe28810
jmp 0x1f3d36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f3d26
leaq 0xd72b3(%rip), %rax     # 0x2cafd0
movq %rax, 0xc34aec(%rip)    # 0xe28810
jmp 0x1f3d34
leaq 0xa55e3(%rip), %rax     # 0x299310
movq %rax, 0xc34adc(%rip)    # 0xe28810
jmp 0x1f3d36
jmp 0x1f3d38
movq 0xc34ad1(%rip), %rax    # 0xe28810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_8_pointer = parasail_sg_qx_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f3dae
leaq 0x6a594b(%rip), %rax    # 0x8996f0
movq %rax, 0xc34a6c(%rip)    # 0xe28818
jmp 0x1f3df8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f3dca
leaq 0x3b6d9f(%rip), %rax    # 0x5aab60
movq %rax, 0xc34a50(%rip)    # 0xe28818
jmp 0x1f3df6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f3de6
leaq 0xdd483(%rip), %rax     # 0x2d1260
movq %rax, 0xc34a34(%rip)    # 0xe28818
jmp 0x1f3df4
leaq 0xa5523(%rip), %rax     # 0x299310
movq %rax, 0xc34a24(%rip)    # 0xe28818
jmp 0x1f3df6
jmp 0x1f3df8
movq 0xc34a19(%rip), %rax    # 0xe28818
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_64_pointer = parasail_sg_qx_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f3e6e
leaq 0x6daa8b(%rip), %rax    # 0x8ce8f0
movq %rax, 0xc349b4(%rip)    # 0xe28820
jmp 0x1f3eb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f3e8a
leaq 0x3d9daf(%rip), %rax    # 0x5cdc30
movq %rax, 0xc34998(%rip)    # 0xe28820
jmp 0x1f3eb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f3ea6
leaq 0x1012a3(%rip), %rax    # 0x2f5140
movq %rax, 0xc3497c(%rip)    # 0xe28820
jmp 0x1f3eb4
leaq 0xa3503(%rip), %rax     # 0x2973b0
movq %rax, 0xc3496c(%rip)    # 0xe28820
jmp 0x1f3eb6
jmp 0x1f3eb8
movq 0xc34961(%rip), %rax    # 0xe28820
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_32_pointer = parasail_sg_qx_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f3f2e
leaq 0x6dffeb(%rip), %rax    # 0x8d3f10
movq %rax, 0xc348fc(%rip)    # 0xe28828
jmp 0x1f3f78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f3f4a
leaq 0x3de73f(%rip), %rax    # 0x5d2680
movq %rax, 0xc348e0(%rip)    # 0xe28828
jmp 0x1f3f76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f3f66
leaq 0x105db3(%rip), %rax    # 0x2f9d10
movq %rax, 0xc348c4(%rip)    # 0xe28828
jmp 0x1f3f74
leaq 0xa3443(%rip), %rax     # 0x2973b0
movq %rax, 0xc348b4(%rip)    # 0xe28828
jmp 0x1f3f76
jmp 0x1f3f78
movq 0xc348a9(%rip), %rax    # 0xe28828
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_16_pointer = parasail_sg_qx_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f3fee
leaq 0x6e5eab(%rip), %rax    # 0x8d9e90
movq %rax, 0xc34844(%rip)    # 0xe28830
jmp 0x1f4038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f400a
leaq 0x3e34cf(%rip), %rax    # 0x5d74d0
movq %rax, 0xc34828(%rip)    # 0xe28830
jmp 0x1f4036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4026
leaq 0x10ac03(%rip), %rax    # 0x2fec20
movq %rax, 0xc3480c(%rip)    # 0xe28830
jmp 0x1f4034
leaq 0xa3383(%rip), %rax     # 0x2973b0
movq %rax, 0xc347fc(%rip)    # 0xe28830
jmp 0x1f4036
jmp 0x1f4038
movq 0xc347f1(%rip), %rax    # 0xe28830
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_8_pointer = parasail_sg_qx_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f40ae
leaq 0x6ed02b(%rip), %rax    # 0x8e10d0
movq %rax, 0xc3478c(%rip)    # 0xe28838
jmp 0x1f40f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f40ca
leaq 0x3e8aaf(%rip), %rax    # 0x5dcb70
movq %rax, 0xc34770(%rip)    # 0xe28838
jmp 0x1f40f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f40e6
leaq 0x1104e3(%rip), %rax    # 0x3045c0
movq %rax, 0xc34754(%rip)    # 0xe28838
jmp 0x1f40f4
leaq 0xa32c3(%rip), %rax     # 0x2973b0
movq %rax, 0xc34744(%rip)    # 0xe28838
jmp 0x1f40f6
jmp 0x1f40f8
movq 0xc34739(%rip), %rax    # 0xe28838
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_diag_64_pointer = parasail_sg_qx_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f416e
leaq 0x6ad80b(%rip), %rax    # 0x8a1970
movq %rax, 0xc346d4(%rip)    # 0xe28840
jmp 0x1f41b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f418a
leaq 0x3bc67f(%rip), %rax    # 0x5b0800
movq %rax, 0xc346b8(%rip)    # 0xe28840
jmp 0x1f41b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f41a6
leaq 0xe2ea3(%rip), %rax     # 0x2d7040
movq %rax, 0xc3469c(%rip)    # 0xe28840
jmp 0x1f41b4
leaq 0xa3203(%rip), %rax     # 0x2973b0
movq %rax, 0xc3468c(%rip)    # 0xe28840
jmp 0x1f41b6
jmp 0x1f41b8
movq 0xc34681(%rip), %rax    # 0xe28840
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_diag_32_pointer = parasail_sg_qx_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f422e
leaq 0x6b58bb(%rip), %rax    # 0x8a9ae0
movq %rax, 0xc3461c(%rip)    # 0xe28848
jmp 0x1f4278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f424a
leaq 0x3c223f(%rip), %rax    # 0x5b6480
movq %rax, 0xc34600(%rip)    # 0xe28848
jmp 0x1f4276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4266
leaq 0xe8c83(%rip), %rax     # 0x2dcee0
movq %rax, 0xc345e4(%rip)    # 0xe28848
jmp 0x1f4274
leaq 0xa3143(%rip), %rax     # 0x2973b0
movq %rax, 0xc345d4(%rip)    # 0xe28848
jmp 0x1f4276
jmp 0x1f4278
movq 0xc345c9(%rip), %rax    # 0xe28848
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_diag_16_pointer = parasail_sg_qx_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f42ee
leaq 0x6c07ab(%rip), %rax    # 0x8b4a90
movq %rax, 0xc34564(%rip)    # 0xe28850
jmp 0x1f4338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f430a
leaq 0x3c936f(%rip), %rax    # 0x5bd670
movq %rax, 0xc34548(%rip)    # 0xe28850
jmp 0x1f4336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4326
leaq 0xeff93(%rip), %rax     # 0x2e42b0
movq %rax, 0xc3452c(%rip)    # 0xe28850
jmp 0x1f4334
leaq 0xa3083(%rip), %rax     # 0x2973b0
movq %rax, 0xc3451c(%rip)    # 0xe28850
jmp 0x1f4336
jmp 0x1f4338
movq 0xc34511(%rip), %rax    # 0xe28850
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_diag_8_pointer = parasail_sg_qx_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f43ae
leaq 0x6d0e9b(%rip), %rax    # 0x8c5240
movq %rax, 0xc344ac(%rip)    # 0xe28858
jmp 0x1f43f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f43ca
leaq 0x3d2d8f(%rip), %rax    # 0x5c7150
movq %rax, 0xc34490(%rip)    # 0xe28858
jmp 0x1f43f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f43e6
leaq 0xf9fc3(%rip), %rax     # 0x2ee3a0
movq %rax, 0xc34474(%rip)    # 0xe28858
jmp 0x1f43f4
leaq 0xa2fc3(%rip), %rax     # 0x2973b0
movq %rax, 0xc34464(%rip)    # 0xe28858
jmp 0x1f43f6
jmp 0x1f43f8
movq 0xc34459(%rip), %rax    # 0xe28858
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f446e
leaq 0x6f7e6b(%rip), %rax    # 0x8ec2d0
movq %rax, 0xc343f4(%rip)    # 0xe28860
jmp 0x1f44b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f448a
leaq 0x3f2def(%rip), %rax    # 0x5e7270
movq %rax, 0xc343d8(%rip)    # 0xe28860
jmp 0x1f44b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f44a6
leaq 0x118933(%rip), %rax    # 0x30cdd0
movq %rax, 0xc343bc(%rip)    # 0xe28860
jmp 0x1f44b4
leaq 0xa4e63(%rip), %rax     # 0x299310
movq %rax, 0xc343ac(%rip)    # 0xe28860
jmp 0x1f44b6
jmp 0x1f44b8
movq 0xc343a1(%rip), %rax    # 0xe28860
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f452e
leaq 0x70505b(%rip), %rax    # 0x8f9580
movq %rax, 0xc3433c(%rip)    # 0xe28868
jmp 0x1f4578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f454a
leaq 0x3fd77f(%rip), %rax    # 0x5f1cc0
movq %rax, 0xc34320(%rip)    # 0xe28868
jmp 0x1f4576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4566
leaq 0x122563(%rip), %rax    # 0x316ac0
movq %rax, 0xc34304(%rip)    # 0xe28868
jmp 0x1f4574
leaq 0xa4da3(%rip), %rax     # 0x299310
movq %rax, 0xc342f4(%rip)    # 0xe28868
jmp 0x1f4576
jmp 0x1f4578
movq 0xc342e9(%rip), %rax    # 0xe28868
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f45ee
leaq 0x71380b(%rip), %rax    # 0x907df0
movq %rax, 0xc34284(%rip)    # 0xe28870
jmp 0x1f4638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f460a
leaq 0x4087ef(%rip), %rax    # 0x5fcdf0
movq %rax, 0xc34268(%rip)    # 0xe28870
jmp 0x1f4636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4626
leaq 0x12c803(%rip), %rax    # 0x320e20
movq %rax, 0xc3424c(%rip)    # 0xe28870
jmp 0x1f4634
leaq 0xa4ce3(%rip), %rax     # 0x299310
movq %rax, 0xc3423c(%rip)    # 0xe28870
jmp 0x1f4636
jmp 0x1f4638
movq 0xc34231(%rip), %rax    # 0xe28870
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f46ae
leaq 0x72473b(%rip), %rax    # 0x918de0
movq %rax, 0xc341cc(%rip)    # 0xe28878
jmp 0x1f46f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f46ca
leaq 0x41431f(%rip), %rax    # 0x6089e0
movq %rax, 0xc341b0(%rip)    # 0xe28878
jmp 0x1f46f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f46e6
leaq 0x137773(%rip), %rax    # 0x32be50
movq %rax, 0xc34194(%rip)    # 0xe28878
jmp 0x1f46f4
leaq 0xa4c23(%rip), %rax     # 0x299310
movq %rax, 0xc34184(%rip)    # 0xe28878
jmp 0x1f46f6
jmp 0x1f46f8
movq 0xc34179(%rip), %rax    # 0xe28878
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f476e
leaq 0x7753ab(%rip), %rax    # 0x969b10
movq %rax, 0xc34114(%rip)    # 0xe28880
jmp 0x1f47b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f478a
leaq 0x44c49f(%rip), %rax    # 0x640c20
movq %rax, 0xc340f8(%rip)    # 0xe28880
jmp 0x1f47b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f47a6
leaq 0x16db63(%rip), %rax    # 0x362300
movq %rax, 0xc340dc(%rip)    # 0xe28880
jmp 0x1f47b4
leaq 0xa2c03(%rip), %rax     # 0x2973b0
movq %rax, 0xc340cc(%rip)    # 0xe28880
jmp 0x1f47b6
jmp 0x1f47b8
movq 0xc340c1(%rip), %rax    # 0xe28880
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f482e
leaq 0x7802ab(%rip), %rax    # 0x974ad0
movq %rax, 0xc3405c(%rip)    # 0xe28888
jmp 0x1f4878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f484a
leaq 0x45587f(%rip), %rax    # 0x64a0c0
movq %rax, 0xc34040(%rip)    # 0xe28888
jmp 0x1f4876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4866
leaq 0x176843(%rip), %rax    # 0x36b0a0
movq %rax, 0xc34024(%rip)    # 0xe28888
jmp 0x1f4874
leaq 0xa2b43(%rip), %rax     # 0x2973b0
movq %rax, 0xc34014(%rip)    # 0xe28888
jmp 0x1f4876
jmp 0x1f4878
movq 0xc34009(%rip), %rax    # 0xe28888
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f48ee
leaq 0x78be2b(%rip), %rax    # 0x980710
movq %rax, 0xc33fa4(%rip)    # 0xe28890
jmp 0x1f4938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f490a
leaq 0x45f22f(%rip), %rax    # 0x653b30
movq %rax, 0xc33f88(%rip)    # 0xe28890
jmp 0x1f4936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4926
leaq 0x17f983(%rip), %rax    # 0x3742a0
movq %rax, 0xc33f6c(%rip)    # 0xe28890
jmp 0x1f4934
leaq 0xa2a83(%rip), %rax     # 0x2973b0
movq %rax, 0xc33f5c(%rip)    # 0xe28890
jmp 0x1f4936
jmp 0x1f4938
movq 0xc33f51(%rip), %rax    # 0xe28890
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)