LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21ac23
leaq 0x2a7d07(%rip), %rax    # 0x4c2928
jmp 0x21ac52
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ac37
leaq 0x1b8b7c(%rip), %rax    # 0x3d37b1
jmp 0x21ac52
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ac4b
leaq 0x80421(%rip), %rax     # 0x29b06a
jmp 0x21ac52
leaq 0xa958d(%rip), %rax     # 0x2c41df
movq %rax, 0x5be317(%rip)    # 0x7d8f70
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21acac
leaq 0x2aaba7(%rip), %rax    # 0x4c5851
jmp 0x21acdb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21acc0
leaq 0x1ba85f(%rip), %rax    # 0x3d551d
jmp 0x21acdb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21acd4
leaq 0x80398(%rip), %rax     # 0x29b06a
jmp 0x21acdb
leaq 0xabb06(%rip), %rax     # 0x2c67e1
movq %rax, 0x5be296(%rip)    # 0x7d8f78
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_diag_64_pointer = parasail_sg_qb_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21ad35
leaq 0x29b4fd(%rip), %rax    # 0x4b6230
jmp 0x21ad64
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ad49
leaq 0x1ae48b(%rip), %rax    # 0x3c91d2
jmp 0x21ad64
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ad5d
leaq 0x8030f(%rip), %rax     # 0x29b06a
jmp 0x21ad64
leaq 0x9d147(%rip), %rax     # 0x2b7eab
movq %rax, 0x5be215(%rip)    # 0x7d8f80
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_diag_32_pointer = parasail_sg_qb_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21adbe
leaq 0x29d150(%rip), %rax    # 0x4b7f0c
jmp 0x21aded
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21add2
leaq 0x1afc7c(%rip), %rax    # 0x3caa4c
jmp 0x21aded
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ade6
leaq 0x80286(%rip), %rax     # 0x29b06a
jmp 0x21aded
leaq 0x9edcd(%rip), %rax     # 0x2b9bba
movq %rax, 0x5be194(%rip)    # 0x7d8f88
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_diag_16_pointer = parasail_sg_qb_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21ae47
leaq 0x29f52d(%rip), %rax    # 0x4ba372
jmp 0x21ae76
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ae5b
leaq 0x1b17c3(%rip), %rax    # 0x3cc61c
jmp 0x21ae76
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ae6f
leaq 0x801fd(%rip), %rax     # 0x29b06a
jmp 0x21ae76
leaq 0xa0bc4(%rip), %rax     # 0x2bba3a
movq %rax, 0x5be113(%rip)    # 0x7d8f90
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_diag_8_pointer = parasail_sg_qb_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21aed0
leaq 0x2a23f9(%rip), %rax    # 0x4bd2c7
jmp 0x21aeff
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21aee4
leaq 0x1b3ab5(%rip), %rax    # 0x3ce997
jmp 0x21aeff
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21aef8
leaq 0x80174(%rip), %rax     # 0x29b06a
jmp 0x21aeff
leaq 0xa34f7(%rip), %rax     # 0x2be3f6
movq %rax, 0x5be092(%rip)    # 0x7d8f98
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21af59
leaq 0x2ad0da(%rip), %rax    # 0x4c8031
jmp 0x21af88
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21af6d
leaq 0x1bd542(%rip), %rax    # 0x3d84ad
jmp 0x21af88
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21af81
leaq 0x813e7(%rip), %rax     # 0x29c366
jmp 0x21af88
leaq 0xaec86(%rip), %rax     # 0x2c9c0e
movq %rax, 0x5be011(%rip)    # 0x7d8fa0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21afe2
leaq 0x2affdf(%rip), %rax    # 0x4cafbf
jmp 0x21b011
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21aff6
leaq 0x1c056c(%rip), %rax    # 0x3db560
jmp 0x21b011
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b00a
leaq 0x8135e(%rip), %rax     # 0x29c366
jmp 0x21b011
leaq 0xb252a(%rip), %rax     # 0x2cd53b
movq %rax, 0x5bdf90(%rip)    # 0x7d8fa8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b06b
leaq 0x2b3722(%rip), %rax    # 0x4ce78b
jmp 0x21b09a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b07f
leaq 0x1c392f(%rip), %rax    # 0x3de9ac
jmp 0x21b09a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b093
leaq 0x812d5(%rip), %rax     # 0x29c366
jmp 0x21b09a
leaq 0xb60d3(%rip), %rax     # 0x2d116d
movq %rax, 0x5bdf0f(%rip)    # 0x7d8fb0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b0f4
leaq 0x2b7993(%rip), %rax    # 0x4d2a85
jmp 0x21b123
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b108
leaq 0x1c712f(%rip), %rax    # 0x3e2235
jmp 0x21b123
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b11c
leaq 0x8124c(%rip), %rax     # 0x29c366
jmp 0x21b123
leaq 0xba5cd(%rip), %rax     # 0x2d56f0
movq %rax, 0x5bde8e(%rip)    # 0x7d8fb8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b17d
leaq 0x2ca9ba(%rip), %rax    # 0x4e5b35
jmp 0x21b1ac
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b191
leaq 0x1d80e3(%rip), %rax    # 0x3f3272
jmp 0x21b1ac
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b1a5
leaq 0x7fec7(%rip), %rax     # 0x29b06a
jmp 0x21b1ac
leaq 0xce7f7(%rip), %rax     # 0x2e99a3
movq %rax, 0x5bde0d(%rip)    # 0x7d8fc0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b206
leaq 0x2cd66d(%rip), %rax    # 0x4e8871
jmp 0x21b235
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b21a
leaq 0x1daeda(%rip), %rax    # 0x3f60f2
jmp 0x21b235
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b22e
leaq 0x7fe3e(%rip), %rax     # 0x29b06a
jmp 0x21b235
leaq 0xd212d(%rip), %rax     # 0x2ed362
movq %rax, 0x5bdd8c(%rip)    # 0x7d8fc8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b28f
leaq 0x2d0d7a(%rip), %rax    # 0x4ec007
jmp 0x21b2be
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b2a3
leaq 0x1de062(%rip), %rax    # 0x3f9303
jmp 0x21b2be
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b2b7
leaq 0x7fdb5(%rip), %rax     # 0x29b06a
jmp 0x21b2be
leaq 0xd57d9(%rip), %rax     # 0x2f0a97
movq %rax, 0x5bdd0b(%rip)    # 0x7d8fd0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b318
leaq 0x2d5408(%rip), %rax    # 0x4f071e
jmp 0x21b347
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b32c
leaq 0x1e15d7(%rip), %rax    # 0x3fc901
jmp 0x21b347
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b340
leaq 0x7fd2c(%rip), %rax     # 0x29b06a
jmp 0x21b347
leaq 0xd9876(%rip), %rax     # 0x2f4bbd
movq %rax, 0x5bdc8a(%rip)    # 0x7d8fd8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b3a1
leaq 0x2baac5(%rip), %rax    # 0x4d5e64
jmp 0x21b3d0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b3b5
leaq 0x1ca0f0(%rip), %rax    # 0x3e54a3
jmp 0x21b3d0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b3c9
leaq 0x7fca3(%rip), %rax     # 0x29b06a
jmp 0x21b3d0
leaq 0xbe0e1(%rip), %rax     # 0x2d94b1
movq %rax, 0x5bdc09(%rip)    # 0x7d8fe0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b42a
leaq 0x2be03d(%rip), %rax    # 0x4d9465
jmp 0x21b459
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b43e
leaq 0x1cd1cc(%rip), %rax    # 0x3e8608
jmp 0x21b459
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b452
leaq 0x7fc1a(%rip), %rax     # 0x29b06a
jmp 0x21b459
leaq 0xc1ae8(%rip), %rax     # 0x2dcf41
movq %rax, 0x5bdb88(%rip)    # 0x7d8fe8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b4b3
leaq 0x2c1f88(%rip), %rax    # 0x4dd439
jmp 0x21b4e2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b4c7
leaq 0x1d084e(%rip), %rax    # 0x3ebd13
jmp 0x21b4e2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b4db
leaq 0x7fb91(%rip), %rax     # 0x29b06a
jmp 0x21b4e2
leaq 0xc547d(%rip), %rax     # 0x2e095f
movq %rax, 0x5bdb07(%rip)    # 0x7d8ff0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_stats_diag_8_pointer = parasail_sg_qb_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b53c
leaq 0x2c6d13(%rip), %rax    # 0x4e224d
jmp 0x21b56b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b550
leaq 0x1d4861(%rip), %rax    # 0x3efdaf
jmp 0x21b56b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b564
leaq 0x7fb08(%rip), %rax     # 0x29b06a
jmp 0x21b56b
leaq 0xca022(%rip), %rax     # 0x2e558d
movq %rax, 0x5bda86(%rip)    # 0x7d8ff8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b5c5
leaq 0x2d85dd(%rip), %rax    # 0x4f3ba0
jmp 0x21b5f4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b5d9
leaq 0x1e3595(%rip), %rax    # 0x3feb6c
jmp 0x21b5f4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b5ed
leaq 0x80d7b(%rip), %rax     # 0x29c366
jmp 0x21b5f4
leaq 0xdd102(%rip), %rax     # 0x2f86f6
movq %rax, 0x5bda05(%rip)    # 0x7d9000
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b64e
leaq 0x2da217(%rip), %rax    # 0x4f5863
jmp 0x21b67d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b662
leaq 0x1e50a3(%rip), %rax    # 0x400703
jmp 0x21b67d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b676
leaq 0x80cf2(%rip), %rax     # 0x29c366
jmp 0x21b67d
leaq 0xdf0d5(%rip), %rax     # 0x2fa752
movq %rax, 0x5bd984(%rip)    # 0x7d9008
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b6d7
leaq 0x2dcd6d(%rip), %rax    # 0x4f8442
jmp 0x21b706
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b6eb
leaq 0x1e705d(%rip), %rax    # 0x402746
jmp 0x21b706
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b6ff
leaq 0x80c69(%rip), %rax     # 0x29c366
jmp 0x21b706
leaq 0xe14de(%rip), %rax     # 0x2fcbe4
movq %rax, 0x5bd903(%rip)    # 0x7d9010
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21b760
leaq 0x2e0b80(%rip), %rax    # 0x4fc2de
jmp 0x21b78f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b774
leaq 0x1e97cd(%rip), %rax    # 0x404f3f
jmp 0x21b78f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b788
leaq 0x80be0(%rip), %rax     # 0x29c366
jmp 0x21b78f
leaq 0xe45a0(%rip), %rax     # 0x2ffd2f
movq %rax, 0x5bd882(%rip)    # 0x7d9018
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax