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_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_trace_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_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1ee9ae
leaq 0xa3597b(%rip), %rax    # 0xc24320
movq %rax, 0xc39c74(%rip)    # 0xe28620
jmp 0x1ee9f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee9ca
leaq 0x64ab5f(%rip), %rax    # 0x839520
movq %rax, 0xc39c58(%rip)    # 0xe28620
jmp 0x1ee9f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee9e6
leaq 0x361a03(%rip), %rax    # 0x5503e0
movq %rax, 0xc39c3c(%rip)    # 0xe28620
jmp 0x1ee9f4
leaq 0xa8953(%rip), %rax     # 0x297340
movq %rax, 0xc39c2c(%rip)    # 0xe28620
jmp 0x1ee9f6
jmp 0x1ee9f8
movq 0xc39c21(%rip), %rax    # 0xe28620
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_qe_dispatch.c
// Function: parasail_sg_qe_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_trace_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_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1eea6e
leaq 0xa3feab(%rip), %rax    # 0xc2e910
movq %rax, 0xc39bbc(%rip)    # 0xe28628
jmp 0x1eeab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eea8a
leaq 0x651cdf(%rip), %rax    # 0x840760
movq %rax, 0xc39ba0(%rip)    # 0xe28628
jmp 0x1eeab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eeaa6
leaq 0x368bb3(%rip), %rax    # 0x557650
movq %rax, 0xc39b84(%rip)    # 0xe28628
jmp 0x1eeab4
leaq 0xa8893(%rip), %rax     # 0x297340
movq %rax, 0xc39b74(%rip)    # 0xe28628
jmp 0x1eeab6
jmp 0x1eeab8
movq 0xc39b69(%rip), %rax    # 0xe28628
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_qe_dispatch.c
// Function: parasail_sg_qe_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_trace_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_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1eeb2e
leaq 0xa4e7cb(%rip), %rax    # 0xc3d2f0
movq %rax, 0xc39b04(%rip)    # 0xe28630
jmp 0x1eeb78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eeb4a
leaq 0x65adef(%rip), %rax    # 0x849930
movq %rax, 0xc39ae8(%rip)    # 0xe28630
jmp 0x1eeb76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eeb66
leaq 0x371de3(%rip), %rax    # 0x560940
movq %rax, 0xc39acc(%rip)    # 0xe28630
jmp 0x1eeb74
leaq 0xa87d3(%rip), %rax     # 0x297340
movq %rax, 0xc39abc(%rip)    # 0xe28630
jmp 0x1eeb76
jmp 0x1eeb78
movq 0xc39ab1(%rip), %rax    # 0xe28630
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_qe_dispatch.c
// Function: parasail_sg_qe_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_trace_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_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1eebee
leaq 0xa652cb(%rip), %rax    # 0xc53eb0
movq %rax, 0xc39a4c(%rip)    # 0xe28638
jmp 0x1eec38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eec0a
leaq 0x667aef(%rip), %rax    # 0x8566f0
movq %rax, 0xc39a30(%rip)    # 0xe28638
jmp 0x1eec36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eec26
leaq 0x37f173(%rip), %rax    # 0x56dd90
movq %rax, 0xc39a14(%rip)    # 0xe28638
jmp 0x1eec34
leaq 0xa8713(%rip), %rax     # 0x297340
movq %rax, 0xc39a04(%rip)    # 0xe28638
jmp 0x1eec36
jmp 0x1eec38
movq 0xc399f9(%rip), %rax    # 0xe28638
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_scan_profile_64_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 0x1eeca6
leaq 0x6948b3(%rip), %rax    # 0x883550
movq %rax, 0xc3999c(%rip)    # 0xe28640
jmp 0x1eecec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eecc2
leaq 0x3ab987(%rip), %rax    # 0x59a640
movq %rax, 0xc39980(%rip)    # 0xe28640
jmp 0x1eecea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eecde
leaq 0xd1a2b(%rip), %rax     # 0x2c0700
movq %rax, 0xc39964(%rip)    # 0xe28640
jmp 0x1eece8
movq $0x0, -0x8(%rbp)
jmp 0x1eed0b
jmp 0x1eecea
jmp 0x1eecec
movq 0xc3994d(%rip), %rax    # 0xe28640
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_scan_profile_32_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 0x1eed56
leaq 0x69ace3(%rip), %rax    # 0x889a30
movq %rax, 0xc398f4(%rip)    # 0xe28648
jmp 0x1eed9c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eed72
leaq 0x3b0b57(%rip), %rax    # 0x59f8c0
movq %rax, 0xc398d8(%rip)    # 0xe28648
jmp 0x1eed9a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eed8e
leaq 0xd6ddb(%rip), %rax     # 0x2c5b60
movq %rax, 0xc398bc(%rip)    # 0xe28648
jmp 0x1eed98
movq $0x0, -0x8(%rbp)
jmp 0x1eedbb
jmp 0x1eed9a
jmp 0x1eed9c
movq 0xc398a5(%rip), %rax    # 0xe28648
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_scan_profile_16_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 0x1eee06
leaq 0x6a1f73(%rip), %rax    # 0x890d70
movq %rax, 0xc3984c(%rip)    # 0xe28650
jmp 0x1eee4c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eee22
leaq 0x3b6227(%rip), %rax    # 0x5a5040
movq %rax, 0xc39830(%rip)    # 0xe28650
jmp 0x1eee4a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eee3e
leaq 0xdc5eb(%rip), %rax     # 0x2cb420
movq %rax, 0xc39814(%rip)    # 0xe28650
jmp 0x1eee48
movq $0x0, -0x8(%rbp)
jmp 0x1eee6b
jmp 0x1eee4a
jmp 0x1eee4c
movq 0xc397fd(%rip), %rax    # 0xe28650
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_scan_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 0x1eeeb6
leaq 0x6aac93(%rip), %rax    # 0x899b40
movq %rax, 0xc397a4(%rip)    # 0xe28658
jmp 0x1eeefc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eeed2
leaq 0x3bc0e7(%rip), %rax    # 0x5aafb0
movq %rax, 0xc39788(%rip)    # 0xe28658
jmp 0x1eeefa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eeeee
leaq 0xe27cb(%rip), %rax     # 0x2d16b0
movq %rax, 0xc3976c(%rip)    # 0xe28658
jmp 0x1eeef8
movq $0x0, -0x8(%rbp)
jmp 0x1eef1b
jmp 0x1eeefa
jmp 0x1eeefc
movq 0xc39755(%rip), %rax    # 0xe28658
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_striped_profile_64_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 0x1eef66
leaq 0x6dfde3(%rip), %rax    # 0x8ced40
movq %rax, 0xc396fc(%rip)    # 0xe28660
jmp 0x1eefac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eef82
leaq 0x3df107(%rip), %rax    # 0x5ce080
movq %rax, 0xc396e0(%rip)    # 0xe28660
jmp 0x1eefaa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eef9e
leaq 0x1065fb(%rip), %rax    # 0x2f5590
movq %rax, 0xc396c4(%rip)    # 0xe28660
jmp 0x1eefa8
movq $0x0, -0x8(%rbp)
jmp 0x1eefcb
jmp 0x1eefaa
jmp 0x1eefac
movq 0xc396ad(%rip), %rax    # 0xe28660
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_striped_profile_32_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 0x1ef016
leaq 0x6e5353(%rip), %rax    # 0x8d4360
movq %rax, 0xc39654(%rip)    # 0xe28668
jmp 0x1ef05c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef032
leaq 0x3e3aa7(%rip), %rax    # 0x5d2ad0
movq %rax, 0xc39638(%rip)    # 0xe28668
jmp 0x1ef05a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef04e
leaq 0x10b11b(%rip), %rax    # 0x2fa160
movq %rax, 0xc3961c(%rip)    # 0xe28668
jmp 0x1ef058
movq $0x0, -0x8(%rbp)
jmp 0x1ef07b
jmp 0x1ef05a
jmp 0x1ef05c
movq 0xc39605(%rip), %rax    # 0xe28668
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_striped_profile_16_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 0x1ef0c6
leaq 0x6eb223(%rip), %rax    # 0x8da2e0
movq %rax, 0xc395ac(%rip)    # 0xe28670
jmp 0x1ef10c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef0e2
leaq 0x3e8847(%rip), %rax    # 0x5d7920
movq %rax, 0xc39590(%rip)    # 0xe28670
jmp 0x1ef10a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef0fe
leaq 0x10ff7b(%rip), %rax    # 0x2ff070
movq %rax, 0xc39574(%rip)    # 0xe28670
jmp 0x1ef108
movq $0x0, -0x8(%rbp)
jmp 0x1ef12b
jmp 0x1ef10a
jmp 0x1ef10c
movq 0xc3955d(%rip), %rax    # 0xe28670
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_profile_8_pointer = parasail_sg_qe_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x1ef176
leaq 0x6f23b3(%rip), %rax    # 0x8e1520
movq %rax, 0xc39504(%rip)    # 0xe28678
jmp 0x1ef1bc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef192
leaq 0x3ede37(%rip), %rax    # 0x5dcfc0
movq %rax, 0xc394e8(%rip)    # 0xe28678
jmp 0x1ef1ba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef1ae
leaq 0x11586b(%rip), %rax    # 0x304a10
movq %rax, 0xc394cc(%rip)    # 0xe28678
jmp 0x1ef1b8
movq $0x0, -0x8(%rbp)
jmp 0x1ef1db
jmp 0x1ef1ba
jmp 0x1ef1bc
movq 0xc394b5(%rip), %rax    # 0xe28678
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_scan_profile_64_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 0x1ef226
leaq 0x6fd503(%rip), %rax    # 0x8ec720
movq %rax, 0xc3945c(%rip)    # 0xe28680
jmp 0x1ef26c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef242
leaq 0x3f8487(%rip), %rax    # 0x5e76c0
movq %rax, 0xc39440(%rip)    # 0xe28680
jmp 0x1ef26a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef25e
leaq 0x11dfcb(%rip), %rax    # 0x30d220
movq %rax, 0xc39424(%rip)    # 0xe28680
jmp 0x1ef268
movq $0x0, -0x8(%rbp)
jmp 0x1ef28b
jmp 0x1ef26a
jmp 0x1ef26c
movq 0xc3940d(%rip), %rax    # 0xe28680
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_scan_profile_32_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 0x1ef2d6
leaq 0x70a703(%rip), %rax    # 0x8f99d0
movq %rax, 0xc393b4(%rip)    # 0xe28688
jmp 0x1ef31c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef2f2
leaq 0x402e27(%rip), %rax    # 0x5f2110
movq %rax, 0xc39398(%rip)    # 0xe28688
jmp 0x1ef31a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef30e
leaq 0x127c0b(%rip), %rax    # 0x316f10
movq %rax, 0xc3937c(%rip)    # 0xe28688
jmp 0x1ef318
movq $0x0, -0x8(%rbp)
jmp 0x1ef33b
jmp 0x1ef31a
jmp 0x1ef31c
movq 0xc39365(%rip), %rax    # 0xe28688
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_scan_profile_16_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 0x1ef386
leaq 0x718ec3(%rip), %rax    # 0x908240
movq %rax, 0xc3930c(%rip)    # 0xe28690
jmp 0x1ef3cc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef3a2
leaq 0x40dea7(%rip), %rax    # 0x5fd240
movq %rax, 0xc392f0(%rip)    # 0xe28690
jmp 0x1ef3ca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef3be
leaq 0x131ebb(%rip), %rax    # 0x321270
movq %rax, 0xc392d4(%rip)    # 0xe28690
jmp 0x1ef3c8
movq $0x0, -0x8(%rbp)
jmp 0x1ef3eb
jmp 0x1ef3ca
jmp 0x1ef3cc
movq 0xc392bd(%rip), %rax    # 0xe28690
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_qe_stats_scan_profile_8_pointer = parasail_sg_qe_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_profile_8_pointer = parasail_sg_qe_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_profile_8_pointer = parasail_sg_qe_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_profile_8_pointer = parasail_sg_qe_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_profile_8_pointer = parasail_sg_qe_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_scan_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 0x1ef436
leaq 0x729e03(%rip), %rax    # 0x919230
movq %rax, 0xc39264(%rip)    # 0xe28698
jmp 0x1ef47c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef452
leaq 0x4199e7(%rip), %rax    # 0x608e30
movq %rax, 0xc39248(%rip)    # 0xe28698
jmp 0x1ef47a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef46e
leaq 0x13ce3b(%rip), %rax    # 0x32c2a0
movq %rax, 0xc3922c(%rip)    # 0xe28698
jmp 0x1ef478
movq $0x0, -0x8(%rbp)
jmp 0x1ef49b
jmp 0x1ef47a
jmp 0x1ef47c
movq 0xc39215(%rip), %rax    # 0xe28698
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_qe_stats_striped_profile_64_pointer = parasail_sg_qe_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_profile_64_pointer = parasail_sg_qe_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_profile_64_pointer = parasail_sg_qe_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_profile_64_pointer = parasail_sg_qe_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_profile_64_pointer = parasail_sg_qe_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_striped_profile_64_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 0x1ef4e6
leaq 0x77aa83(%rip), %rax    # 0x969f60
movq %rax, 0xc391bc(%rip)    # 0xe286a0
jmp 0x1ef52c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef502
leaq 0x451b77(%rip), %rax    # 0x641070
movq %rax, 0xc391a0(%rip)    # 0xe286a0
jmp 0x1ef52a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef51e
leaq 0x17323b(%rip), %rax    # 0x362750
movq %rax, 0xc39184(%rip)    # 0xe286a0
jmp 0x1ef528
movq $0x0, -0x8(%rbp)
jmp 0x1ef54b
jmp 0x1ef52a
jmp 0x1ef52c
movq 0xc3916d(%rip), %rax    # 0xe286a0
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_qe_stats_striped_profile_32_pointer = parasail_sg_qe_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_profile_32_pointer = parasail_sg_qe_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_profile_32_pointer = parasail_sg_qe_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_profile_32_pointer = parasail_sg_qe_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_profile_32_pointer = parasail_sg_qe_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_striped_profile_32_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 0x1ef596
leaq 0x785993(%rip), %rax    # 0x974f20
movq %rax, 0xc39114(%rip)    # 0xe286a8
jmp 0x1ef5dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef5b2
leaq 0x45af67(%rip), %rax    # 0x64a510
movq %rax, 0xc390f8(%rip)    # 0xe286a8
jmp 0x1ef5da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef5ce
leaq 0x17bf2b(%rip), %rax    # 0x36b4f0
movq %rax, 0xc390dc(%rip)    # 0xe286a8
jmp 0x1ef5d8
movq $0x0, -0x8(%rbp)
jmp 0x1ef5fb
jmp 0x1ef5da
jmp 0x1ef5dc
movq 0xc390c5(%rip), %rax    # 0xe286a8
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_qe_stats_striped_profile_16_pointer = parasail_sg_qe_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_profile_16_pointer = parasail_sg_qe_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_profile_16_pointer = parasail_sg_qe_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_profile_16_pointer = parasail_sg_qe_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_profile_16_pointer = parasail_sg_qe_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_striped_profile_16_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 0x1ef646
leaq 0x791523(%rip), %rax    # 0x980b60
movq %rax, 0xc3906c(%rip)    # 0xe286b0
jmp 0x1ef68c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef662
leaq 0x464927(%rip), %rax    # 0x653f80
movq %rax, 0xc39050(%rip)    # 0xe286b0
jmp 0x1ef68a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef67e
leaq 0x18507b(%rip), %rax    # 0x3746f0
movq %rax, 0xc39034(%rip)    # 0xe286b0
jmp 0x1ef688
movq $0x0, -0x8(%rbp)
jmp 0x1ef6ab
jmp 0x1ef68a
jmp 0x1ef68c
movq 0xc3901d(%rip), %rax    # 0xe286b0
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_stats_striped_profile_8_pointer = parasail_sg_qe_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_profile_8_pointer = parasail_sg_qe_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_profile_8_pointer = parasail_sg_qe_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_profile_8_pointer = parasail_sg_qe_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_profile_8_pointer = parasail_sg_qe_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_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 0x1ef6f6
leaq 0x79e983(%rip), %rax    # 0x98e070
movq %rax, 0xc38fc4(%rip)    # 0xe286b8
jmp 0x1ef73c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef712
leaq 0x46ef87(%rip), %rax    # 0x65e690
movq %rax, 0xc38fa8(%rip)    # 0xe286b8
jmp 0x1ef73a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef72e
leaq 0x18eeab(%rip), %rax    # 0x37e5d0
movq %rax, 0xc38f8c(%rip)    # 0xe286b8
jmp 0x1ef738
movq $0x0, -0x8(%rbp)
jmp 0x1ef75b
jmp 0x1ef73a
jmp 0x1ef73c
movq 0xc38f75(%rip), %rax    # 0xe286b8
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)