LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_diag_8_pointer = parasail_sg_qb_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_diag_8_pointer = parasail_sg_qb_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_diag_8_pointer = parasail_sg_qb_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_diag_8_pointer = parasail_sg_qb_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_diag_8_pointer = parasail_sg_qb_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_trace_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e5e2e
leaq 0xa6e01b(%rip), %rax    # 0xc53e40
movq %rax, 0xc423ac(%rip)    # 0xe281d8
jmp 0x1e5e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5e4a
leaq 0x67083f(%rip), %rax    # 0x856680
movq %rax, 0xc42390(%rip)    # 0xe281d8
jmp 0x1e5e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5e66
leaq 0x387ec3(%rip), %rax    # 0x56dd20
movq %rax, 0xc42374(%rip)    # 0xe281d8
jmp 0x1e5e74
leaq 0xb1463(%rip), %rax     # 0x2972d0
movq %rax, 0xc42364(%rip)    # 0xe281d8
jmp 0x1e5e76
jmp 0x1e5e78
movq 0xc42359(%rip), %rax    # 0xe281d8
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_qb_dispatch.c
// Function: parasail_sg_qb_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_scan_profile_64_pointer = parasail_sg_qb_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_profile_64_pointer = parasail_sg_qb_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_profile_64_pointer = parasail_sg_qb_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_profile_64_pointer = parasail_sg_qb_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_profile_64_pointer = parasail_sg_qb_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e5ee6
leaq 0x69d613(%rip), %rax    # 0x8834f0
movq %rax, 0xc422fc(%rip)    # 0xe281e0
jmp 0x1e5f2c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5f02
leaq 0x3b46e7(%rip), %rax    # 0x59a5e0
movq %rax, 0xc422e0(%rip)    # 0xe281e0
jmp 0x1e5f2a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5f1e
leaq 0xda78b(%rip), %rax     # 0x2c06a0
movq %rax, 0xc422c4(%rip)    # 0xe281e0
jmp 0x1e5f28
movq $0x0, -0x8(%rbp)
jmp 0x1e5f4b
jmp 0x1e5f2a
jmp 0x1e5f2c
movq 0xc422ad(%rip), %rax    # 0xe281e0
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_qb_dispatch.c
// Function: parasail_sg_qb_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_scan_profile_32_pointer = parasail_sg_qb_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_profile_32_pointer = parasail_sg_qb_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_profile_32_pointer = parasail_sg_qb_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_profile_32_pointer = parasail_sg_qb_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_profile_32_pointer = parasail_sg_qb_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e5f96
leaq 0x6a3a43(%rip), %rax    # 0x8899d0
movq %rax, 0xc42254(%rip)    # 0xe281e8
jmp 0x1e5fdc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5fb2
leaq 0x3b98b7(%rip), %rax    # 0x59f860
movq %rax, 0xc42238(%rip)    # 0xe281e8
jmp 0x1e5fda
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5fce
leaq 0xdfb3b(%rip), %rax     # 0x2c5b00
movq %rax, 0xc4221c(%rip)    # 0xe281e8
jmp 0x1e5fd8
movq $0x0, -0x8(%rbp)
jmp 0x1e5ffb
jmp 0x1e5fda
jmp 0x1e5fdc
movq 0xc42205(%rip), %rax    # 0xe281e8
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_qb_dispatch.c
// Function: parasail_sg_qb_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_scan_profile_16_pointer = parasail_sg_qb_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_profile_16_pointer = parasail_sg_qb_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_profile_16_pointer = parasail_sg_qb_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_profile_16_pointer = parasail_sg_qb_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_profile_16_pointer = parasail_sg_qb_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6046
leaq 0x6aacd3(%rip), %rax    # 0x890d10
movq %rax, 0xc421ac(%rip)    # 0xe281f0
jmp 0x1e608c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6062
leaq 0x3bef87(%rip), %rax    # 0x5a4fe0
movq %rax, 0xc42190(%rip)    # 0xe281f0
jmp 0x1e608a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e607e
leaq 0xe534b(%rip), %rax     # 0x2cb3c0
movq %rax, 0xc42174(%rip)    # 0xe281f0
jmp 0x1e6088
movq $0x0, -0x8(%rbp)
jmp 0x1e60ab
jmp 0x1e608a
jmp 0x1e608c
movq 0xc4215d(%rip), %rax    # 0xe281f0
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_qb_dispatch.c
// Function: parasail_sg_qb_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_scan_profile_8_pointer = parasail_sg_qb_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_profile_8_pointer = parasail_sg_qb_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_profile_8_pointer = parasail_sg_qb_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_profile_8_pointer = parasail_sg_qb_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_profile_8_pointer = parasail_sg_qb_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e60f6
leaq 0x6b39f3(%rip), %rax    # 0x899ae0
movq %rax, 0xc42104(%rip)    # 0xe281f8
jmp 0x1e613c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6112
leaq 0x3c4e47(%rip), %rax    # 0x5aaf50
movq %rax, 0xc420e8(%rip)    # 0xe281f8
jmp 0x1e613a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e612e
leaq 0xeb52b(%rip), %rax     # 0x2d1650
movq %rax, 0xc420cc(%rip)    # 0xe281f8
jmp 0x1e6138
movq $0x0, -0x8(%rbp)
jmp 0x1e615b
jmp 0x1e613a
jmp 0x1e613c
movq 0xc420b5(%rip), %rax    # 0xe281f8
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_qb_dispatch.c
// Function: parasail_sg_qb_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_profile_64_pointer = parasail_sg_qb_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_profile_64_pointer = parasail_sg_qb_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_profile_64_pointer = parasail_sg_qb_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_profile_64_pointer = parasail_sg_qb_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_profile_64_pointer = parasail_sg_qb_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e61a6
leaq 0x6e8b43(%rip), %rax    # 0x8cece0
movq %rax, 0xc4205c(%rip)    # 0xe28200
jmp 0x1e61ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e61c2
leaq 0x3e7e67(%rip), %rax    # 0x5ce020
movq %rax, 0xc42040(%rip)    # 0xe28200
jmp 0x1e61ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e61de
leaq 0x10f35b(%rip), %rax    # 0x2f5530
movq %rax, 0xc42024(%rip)    # 0xe28200
jmp 0x1e61e8
movq $0x0, -0x8(%rbp)
jmp 0x1e620b
jmp 0x1e61ea
jmp 0x1e61ec
movq 0xc4200d(%rip), %rax    # 0xe28200
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_qb_dispatch.c
// Function: parasail_sg_qb_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_profile_32_pointer = parasail_sg_qb_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_profile_32_pointer = parasail_sg_qb_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_profile_32_pointer = parasail_sg_qb_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_profile_32_pointer = parasail_sg_qb_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_profile_32_pointer = parasail_sg_qb_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6256
leaq 0x6ee0b3(%rip), %rax    # 0x8d4300
movq %rax, 0xc41fb4(%rip)    # 0xe28208
jmp 0x1e629c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6272
leaq 0x3ec807(%rip), %rax    # 0x5d2a70
movq %rax, 0xc41f98(%rip)    # 0xe28208
jmp 0x1e629a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e628e
leaq 0x113e7b(%rip), %rax    # 0x2fa100
movq %rax, 0xc41f7c(%rip)    # 0xe28208
jmp 0x1e6298
movq $0x0, -0x8(%rbp)
jmp 0x1e62bb
jmp 0x1e629a
jmp 0x1e629c
movq 0xc41f65(%rip), %rax    # 0xe28208
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_qb_dispatch.c
// Function: parasail_sg_qb_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_profile_16_pointer = parasail_sg_qb_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_profile_16_pointer = parasail_sg_qb_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_profile_16_pointer = parasail_sg_qb_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_profile_16_pointer = parasail_sg_qb_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_profile_16_pointer = parasail_sg_qb_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6306
leaq 0x6f3f83(%rip), %rax    # 0x8da280
movq %rax, 0xc41f0c(%rip)    # 0xe28210
jmp 0x1e634c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6322
leaq 0x3f15a7(%rip), %rax    # 0x5d78c0
movq %rax, 0xc41ef0(%rip)    # 0xe28210
jmp 0x1e634a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e633e
leaq 0x118cdb(%rip), %rax    # 0x2ff010
movq %rax, 0xc41ed4(%rip)    # 0xe28210
jmp 0x1e6348
movq $0x0, -0x8(%rbp)
jmp 0x1e636b
jmp 0x1e634a
jmp 0x1e634c
movq 0xc41ebd(%rip), %rax    # 0xe28210
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_qb_dispatch.c
// Function: parasail_sg_qb_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_profile_8_pointer = parasail_sg_qb_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_profile_8_pointer = parasail_sg_qb_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_profile_8_pointer = parasail_sg_qb_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_profile_8_pointer = parasail_sg_qb_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_profile_8_pointer = parasail_sg_qb_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e63b6
leaq 0x6fb113(%rip), %rax    # 0x8e14c0
movq %rax, 0xc41e64(%rip)    # 0xe28218
jmp 0x1e63fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e63d2
leaq 0x3f6b97(%rip), %rax    # 0x5dcf60
movq %rax, 0xc41e48(%rip)    # 0xe28218
jmp 0x1e63fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e63ee
leaq 0x11e5cb(%rip), %rax    # 0x3049b0
movq %rax, 0xc41e2c(%rip)    # 0xe28218
jmp 0x1e63f8
movq $0x0, -0x8(%rbp)
jmp 0x1e641b
jmp 0x1e63fa
jmp 0x1e63fc
movq 0xc41e15(%rip), %rax    # 0xe28218
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_scan_profile_64_pointer = parasail_sg_qb_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_profile_64_pointer = parasail_sg_qb_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_profile_64_pointer = parasail_sg_qb_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_profile_64_pointer = parasail_sg_qb_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_profile_64_pointer = parasail_sg_qb_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6466
leaq 0x706263(%rip), %rax    # 0x8ec6c0
movq %rax, 0xc41dbc(%rip)    # 0xe28220
jmp 0x1e64ac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6482
leaq 0x4011e7(%rip), %rax    # 0x5e7660
movq %rax, 0xc41da0(%rip)    # 0xe28220
jmp 0x1e64aa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e649e
leaq 0x126d2b(%rip), %rax    # 0x30d1c0
movq %rax, 0xc41d84(%rip)    # 0xe28220
jmp 0x1e64a8
movq $0x0, -0x8(%rbp)
jmp 0x1e64cb
jmp 0x1e64aa
jmp 0x1e64ac
movq 0xc41d6d(%rip), %rax    # 0xe28220
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_profile_32_pointer = parasail_sg_qb_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6516
leaq 0x713463(%rip), %rax    # 0x8f9970
movq %rax, 0xc41d14(%rip)    # 0xe28228
jmp 0x1e655c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6532
leaq 0x40bb87(%rip), %rax    # 0x5f20b0
movq %rax, 0xc41cf8(%rip)    # 0xe28228
jmp 0x1e655a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e654e
leaq 0x13096b(%rip), %rax    # 0x316eb0
movq %rax, 0xc41cdc(%rip)    # 0xe28228
jmp 0x1e6558
movq $0x0, -0x8(%rbp)
jmp 0x1e657b
jmp 0x1e655a
jmp 0x1e655c
movq 0xc41cc5(%rip), %rax    # 0xe28228
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_profile_16_pointer = parasail_sg_qb_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e65c6
leaq 0x721c23(%rip), %rax    # 0x9081e0
movq %rax, 0xc41c6c(%rip)    # 0xe28230
jmp 0x1e660c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e65e2
leaq 0x416c07(%rip), %rax    # 0x5fd1e0
movq %rax, 0xc41c50(%rip)    # 0xe28230
jmp 0x1e660a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e65fe
leaq 0x13ac1b(%rip), %rax    # 0x321210
movq %rax, 0xc41c34(%rip)    # 0xe28230
jmp 0x1e6608
movq $0x0, -0x8(%rbp)
jmp 0x1e662b
jmp 0x1e660a
jmp 0x1e660c
movq 0xc41c1d(%rip), %rax    # 0xe28230
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_profile_8_pointer = parasail_sg_qb_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6676
leaq 0x732b63(%rip), %rax    # 0x9191d0
movq %rax, 0xc41bc4(%rip)    # 0xe28238
jmp 0x1e66bc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6692
leaq 0x422747(%rip), %rax    # 0x608dd0
movq %rax, 0xc41ba8(%rip)    # 0xe28238
jmp 0x1e66ba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e66ae
leaq 0x145b9b(%rip), %rax    # 0x32c240
movq %rax, 0xc41b8c(%rip)    # 0xe28238
jmp 0x1e66b8
movq $0x0, -0x8(%rbp)
jmp 0x1e66db
jmp 0x1e66ba
jmp 0x1e66bc
movq 0xc41b75(%rip), %rax    # 0xe28238
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_64_pointer = parasail_sg_qb_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6726
leaq 0x7837e3(%rip), %rax    # 0x969f00
movq %rax, 0xc41b1c(%rip)    # 0xe28240
jmp 0x1e676c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6742
leaq 0x45a8d7(%rip), %rax    # 0x641010
movq %rax, 0xc41b00(%rip)    # 0xe28240
jmp 0x1e676a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e675e
leaq 0x17bf9b(%rip), %rax    # 0x3626f0
movq %rax, 0xc41ae4(%rip)    # 0xe28240
jmp 0x1e6768
movq $0x0, -0x8(%rbp)
jmp 0x1e678b
jmp 0x1e676a
jmp 0x1e676c
movq 0xc41acd(%rip), %rax    # 0xe28240
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_32_pointer = parasail_sg_qb_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e67d6
leaq 0x78e6f3(%rip), %rax    # 0x974ec0
movq %rax, 0xc41a74(%rip)    # 0xe28248
jmp 0x1e681c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e67f2
leaq 0x463cc7(%rip), %rax    # 0x64a4b0
movq %rax, 0xc41a58(%rip)    # 0xe28248
jmp 0x1e681a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e680e
leaq 0x184c8b(%rip), %rax    # 0x36b490
movq %rax, 0xc41a3c(%rip)    # 0xe28248
jmp 0x1e6818
movq $0x0, -0x8(%rbp)
jmp 0x1e683b
jmp 0x1e681a
jmp 0x1e681c
movq 0xc41a25(%rip), %rax    # 0xe28248
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_16_pointer = parasail_sg_qb_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6886
leaq 0x79a283(%rip), %rax    # 0x980b00
movq %rax, 0xc419cc(%rip)    # 0xe28250
jmp 0x1e68cc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e68a2
leaq 0x46d687(%rip), %rax    # 0x653f20
movq %rax, 0xc419b0(%rip)    # 0xe28250
jmp 0x1e68ca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e68be
leaq 0x18dddb(%rip), %rax    # 0x374690
movq %rax, 0xc41994(%rip)    # 0xe28250
jmp 0x1e68c8
movq $0x0, -0x8(%rbp)
jmp 0x1e68eb
jmp 0x1e68ca
jmp 0x1e68cc
movq 0xc4197d(%rip), %rax    # 0xe28250
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_profile_8_pointer = parasail_sg_qb_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e6936
leaq 0x7a76e3(%rip), %rax    # 0x98e010
movq %rax, 0xc41924(%rip)    # 0xe28258
jmp 0x1e697c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6952
leaq 0x477ce7(%rip), %rax    # 0x65e630
movq %rax, 0xc41908(%rip)    # 0xe28258
jmp 0x1e697a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e696e
leaq 0x197c0b(%rip), %rax    # 0x37e570
movq %rax, 0xc418ec(%rip)    # 0xe28258
jmp 0x1e6978
movq $0x0, -0x8(%rbp)
jmp 0x1e699b
jmp 0x1e697a
jmp 0x1e697c
movq 0xc418d5(%rip), %rax    # 0xe28258
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_table_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_profile_64_pointer = parasail_sg_qb_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_table_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 0x1e69e6
leaq 0x7b3403(%rip), %rax    # 0x999de0
movq %rax, 0xc4187c(%rip)    # 0xe28260
jmp 0x1e6a2c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6a02
leaq 0x47f347(%rip), %rax    # 0x665d40
movq %rax, 0xc41860(%rip)    # 0xe28260
jmp 0x1e6a2a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e6a1e
leaq 0x1a135b(%rip), %rax    # 0x387d70
movq %rax, 0xc41844(%rip)    # 0xe28260
jmp 0x1e6a28
movq $0x0, -0x8(%rbp)
jmp 0x1e6a4b
jmp 0x1e6a2a
jmp 0x1e6a2c
movq 0xc4182d(%rip), %rax    # 0xe28260
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_table_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_profile_32_pointer = parasail_sg_qb_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_table_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 0x1e6a96
leaq 0x7b9d73(%rip), %rax    # 0x9a0800
movq %rax, 0xc417d4(%rip)    # 0xe28268
jmp 0x1e6adc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6ab2
leaq 0x4847e7(%rip), %rax    # 0x66b290
movq %rax, 0xc417b8(%rip)    # 0xe28268
jmp 0x1e6ada
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e6ace
leaq 0x1a6a9b(%rip), %rax    # 0x38d560
movq %rax, 0xc4179c(%rip)    # 0xe28268
jmp 0x1e6ad8
movq $0x0, -0x8(%rbp)
jmp 0x1e6afb
jmp 0x1e6ada
jmp 0x1e6adc
movq 0xc41785(%rip), %rax    # 0xe28268
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_table_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_profile_16_pointer = parasail_sg_qb_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_table_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 0x1e6b46
leaq 0x7c1a43(%rip), %rax    # 0x9a8580
movq %rax, 0xc4172c(%rip)    # 0xe28270
jmp 0x1e6b8c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e6b62
leaq 0x48a3a7(%rip), %rax    # 0x670f00
movq %rax, 0xc41710(%rip)    # 0xe28270
jmp 0x1e6b8a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e6b7e
leaq 0x1ac7eb(%rip), %rax    # 0x393360
movq %rax, 0xc416f4(%rip)    # 0xe28270
jmp 0x1e6b88
movq $0x0, -0x8(%rbp)
jmp 0x1e6bab
jmp 0x1e6b8a
jmp 0x1e6b8c
movq 0xc416dd(%rip), %rax    # 0xe28270
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)