LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_striped_profile_16_pointer = parasail_sg_qb_de_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_profile_16_pointer = parasail_sg_qb_de_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_profile_16_pointer = parasail_sg_qb_de_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_profile_16_pointer = parasail_sg_qb_de_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_profile_16_pointer = parasail_sg_qb_de_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_trace_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23a4fe
leaq 0x357e12(%rip), %rax    # 0x59230e
jmp 0x23a524
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23a512
leaq 0x247c84(%rip), %rax    # 0x482194
jmp 0x23a524
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23a543
leaq 0x16479d(%rip), %rax    # 0x39ecc1
movq %rax, 0x56a8a5(%rip)    # 0x7a4dd0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_striped_profile_8_pointer = parasail_sg_qb_de_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_profile_8_pointer = parasail_sg_qb_de_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_profile_8_pointer = parasail_sg_qb_de_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_profile_8_pointer = parasail_sg_qb_de_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_profile_8_pointer = parasail_sg_qb_de_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_trace_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23a578
leaq 0x359f30(%rip), %rax    # 0x5944a6
jmp 0x23a59e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23a58c
leaq 0x249d24(%rip), %rax    # 0x4842ae
jmp 0x23a59e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23a5bd
leaq 0x166b6d(%rip), %rax    # 0x3a110b
movq %rax, 0x56a833(%rip)    # 0x7a4dd8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_db_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_scan_64_pointer = parasail_sg_qe_db_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_64_pointer = parasail_sg_qe_db_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_64_pointer = parasail_sg_qe_db_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_64_pointer = parasail_sg_qe_db_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_64_pointer = parasail_sg_qe_db_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23aae5
leaq 0x24bad2(%rip), %rax    # 0x4865b5
jmp 0x23ab14
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23aaf9
leaq 0x1682b3(%rip), %rax    # 0x3a2daa
jmp 0x23ab14
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ab0d
leaq 0x5fee1(%rip), %rax     # 0x29a9ec
jmp 0x23ab14
leaq 0x7148b(%rip), %rax     # 0x2abf9f
movq %rax, 0x56a2c5(%rip)    # 0x7a4de0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_db_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_scan_32_pointer = parasail_sg_qe_db_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_32_pointer = parasail_sg_qe_db_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_32_pointer = parasail_sg_qe_db_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_32_pointer = parasail_sg_qe_db_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_32_pointer = parasail_sg_qe_db_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23ab6e
leaq 0x24d58f(%rip), %rax    # 0x4880fb
jmp 0x23ab9d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ab82
leaq 0x169a55(%rip), %rax    # 0x3a45d5
jmp 0x23ab9d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ab96
leaq 0x5fe58(%rip), %rax     # 0x29a9ec
jmp 0x23ab9d
leaq 0x72e6a(%rip), %rax     # 0x2ada07
movq %rax, 0x56a244(%rip)    # 0x7a4de8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_db_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_scan_16_pointer = parasail_sg_qe_db_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_16_pointer = parasail_sg_qe_db_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_16_pointer = parasail_sg_qe_db_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_16_pointer = parasail_sg_qe_db_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_16_pointer = parasail_sg_qe_db_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23abf7
leaq 0x24ebf5(%rip), %rax    # 0x4897ea
jmp 0x23ac26
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ac0b
leaq 0x16b09f(%rip), %rax    # 0x3a5ca8
jmp 0x23ac26
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ac1f
leaq 0x5fdcf(%rip), %rax     # 0x29a9ec
jmp 0x23ac26
leaq 0x745ba(%rip), %rax     # 0x2af1e0
movq %rax, 0x56a1c3(%rip)    # 0x7a4df0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_db_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_scan_8_pointer = parasail_sg_qe_db_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_8_pointer = parasail_sg_qe_db_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_8_pointer = parasail_sg_qe_db_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_8_pointer = parasail_sg_qe_db_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_8_pointer = parasail_sg_qe_db_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_scan_8_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23ac80
leaq 0x250232(%rip), %rax    # 0x48aeb0
jmp 0x23acaf
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ac94
leaq 0x16c6d8(%rip), %rax    # 0x3a736a
jmp 0x23acaf
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23aca8
leaq 0x5fd46(%rip), %rax     # 0x29a9ec
jmp 0x23acaf
leaq 0x75ebe(%rip), %rax     # 0x2b0b6d
movq %rax, 0x56a142(%rip)    # 0x7a4df8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_db_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_striped_64_pointer = parasail_sg_qe_db_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_64_pointer = parasail_sg_qe_db_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_64_pointer = parasail_sg_qe_db_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_64_pointer = parasail_sg_qe_db_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_64_pointer = parasail_sg_qe_db_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_striped_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23ad09
leaq 0x25c8ab(%rip), %rax    # 0x4975b2
jmp 0x23ad38
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ad1d
leaq 0x175c90(%rip), %rax    # 0x3b09ab
jmp 0x23ad38
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ad31
leaq 0x5ee3f(%rip), %rax     # 0x299b6e
jmp 0x23ad38
leaq 0x80315(%rip), %rax     # 0x2bb04d
movq %rax, 0x56a0c1(%rip)    # 0x7a4e00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_db_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_striped_32_pointer = parasail_sg_qe_db_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_32_pointer = parasail_sg_qe_db_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_32_pointer = parasail_sg_qe_db_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_32_pointer = parasail_sg_qe_db_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_32_pointer = parasail_sg_qe_db_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_striped_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23ad92
leaq 0x25dfe3(%rip), %rax    # 0x498d73
jmp 0x23adc1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ada6
leaq 0x177243(%rip), %rax    # 0x3b1fe7
jmp 0x23adc1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23adba
leaq 0x5edb6(%rip), %rax     # 0x299b6e
jmp 0x23adc1
leaq 0x81a58(%rip), %rax     # 0x2bc819
movq %rax, 0x56a040(%rip)    # 0x7a4e08
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_db_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_striped_16_pointer = parasail_sg_qe_db_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_16_pointer = parasail_sg_qe_db_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_16_pointer = parasail_sg_qe_db_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_16_pointer = parasail_sg_qe_db_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_16_pointer = parasail_sg_qe_db_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_striped_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23ae1b
leaq 0x25f408(%rip), %rax    # 0x49a221
jmp 0x23ae4a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ae2f
leaq 0x17865f(%rip), %rax    # 0x3b348c
jmp 0x23ae4a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ae43
leaq 0x5ed2d(%rip), %rax     # 0x299b6e
jmp 0x23ae4a
leaq 0x82f1a(%rip), %rax     # 0x2bdd64
movq %rax, 0x569fbf(%rip)    # 0x7a4e10
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_db_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_striped_8_pointer = parasail_sg_qe_db_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_8_pointer = parasail_sg_qe_db_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_8_pointer = parasail_sg_qe_db_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_8_pointer = parasail_sg_qe_db_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_8_pointer = parasail_sg_qe_db_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_striped_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23aea4
leaq 0x260857(%rip), %rax    # 0x49b6f9
jmp 0x23aed3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23aeb8
leaq 0x179aab(%rip), %rax    # 0x3b4961
jmp 0x23aed3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23aecc
leaq 0x5eca4(%rip), %rax     # 0x299b6e
jmp 0x23aed3
leaq 0x845c5(%rip), %rax     # 0x2bf498
movq %rax, 0x569f3e(%rip)    # 0x7a4e18
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_db_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23af2d
leaq 0x252046(%rip), %rax    # 0x48cf71
jmp 0x23af5c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23af41
leaq 0x16df8d(%rip), %rax    # 0x3a8ecc
jmp 0x23af5c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23af55
leaq 0x5ec1b(%rip), %rax     # 0x299b6e
jmp 0x23af5c
leaq 0x77b1e(%rip), %rax     # 0x2b2a7a
movq %rax, 0x569ebd(%rip)    # 0x7a4e20
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_db_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23afb6
leaq 0x253fc4(%rip), %rax    # 0x48ef78
jmp 0x23afe5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23afca
leaq 0x16f908(%rip), %rax    # 0x3aa8d0
jmp 0x23afe5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23afde
leaq 0x5eb92(%rip), %rax     # 0x299b6e
jmp 0x23afe5
leaq 0x797b4(%rip), %rax     # 0x2b4799
movq %rax, 0x569e3c(%rip)    # 0x7a4e28
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_db_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23b03f
leaq 0x256405(%rip), %rax    # 0x491442
jmp 0x23b06e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b053
leaq 0x1714c7(%rip), %rax    # 0x3ac518
jmp 0x23b06e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b067
leaq 0x5eb09(%rip), %rax     # 0x299b6e
jmp 0x23b06e
leaq 0x7b58a(%rip), %rax     # 0x2b65f8
movq %rax, 0x569dbb(%rip)    # 0x7a4e30
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_db_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23b0c8
leaq 0x259a32(%rip), %rax    # 0x494af8
jmp 0x23b0f7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b0dc
leaq 0x1738e8(%rip), %rax    # 0x3ae9c2
jmp 0x23b0f7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b0f0
leaq 0x5ea80(%rip), %rax     # 0x299b6e
jmp 0x23b0f7
leaq 0x7dd83(%rip), %rax     # 0x2b8e7a
movq %rax, 0x569d3a(%rip)    # 0x7a4e38
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23b151
leaq 0x2637e6(%rip), %rax    # 0x49e935
jmp 0x23b180
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b165
leaq 0x17c97d(%rip), %rax    # 0x3b7ae0
jmp 0x23b180
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b179
leaq 0x5f875(%rip), %rax     # 0x29a9ec
jmp 0x23b180
leaq 0x872c2(%rip), %rax     # 0x2c2442
movq %rax, 0x569cb9(%rip)    # 0x7a4e40
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_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 0x594f9c
testl %eax, %eax
je 0x23b1da
leaq 0x266bc0(%rip), %rax    # 0x4a1d98
jmp 0x23b209
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b1ee
leaq 0x17f9a8(%rip), %rax    # 0x3bab94
jmp 0x23b209
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b202
leaq 0x5f7ec(%rip), %rax     # 0x29a9ec
jmp 0x23b209
leaq 0x8a916(%rip), %rax     # 0x2c5b1f
movq %rax, 0x569c38(%rip)    # 0x7a4e48
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_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 0x594f9c
testl %eax, %eax
je 0x23b263
leaq 0x2699d3(%rip), %rax    # 0x4a4c34
jmp 0x23b292
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b277
leaq 0x18275a(%rip), %rax    # 0x3bd9cf
jmp 0x23b292
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b28b
leaq 0x5f763(%rip), %rax     # 0x29a9ec
jmp 0x23b292
leaq 0x8db62(%rip), %rax     # 0x2c8df4
movq %rax, 0x569bb7(%rip)    # 0x7a4e50
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_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 0x594f9c
testl %eax, %eax
je 0x23b2ec
leaq 0x26c80c(%rip), %rax    # 0x4a7af6
jmp 0x23b31b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b300
leaq 0x1855af(%rip), %rax    # 0x3c08ad
jmp 0x23b31b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b314
leaq 0x5f6da(%rip), %rax     # 0x29a9ec
jmp 0x23b31b
leaq 0x90f72(%rip), %rax     # 0x2cc28d
movq %rax, 0x569b36(%rip)    # 0x7a4e58
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x594f9c
testl %eax, %eax
je 0x23b375
leaq 0x28120e(%rip), %rax    # 0x4bc581
jmp 0x23b3a4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b389
leaq 0x196c96(%rip), %rax    # 0x3d201d
jmp 0x23b3a4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b39d
leaq 0x5e7d3(%rip), %rax     # 0x299b6e
jmp 0x23b3a4
leaq 0xa4758(%rip), %rax     # 0x2dfafc
movq %rax, 0x569ab5(%rip)    # 0x7a4e60
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x594f9c
testl %eax, %eax
je 0x23b3fe
leaq 0x284193(%rip), %rax    # 0x4bf58f
jmp 0x23b42d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b412
leaq 0x199a1b(%rip), %rax    # 0x3d4e2b
jmp 0x23b42d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b426
leaq 0x5e74a(%rip), %rax     # 0x299b6e
jmp 0x23b42d
leaq 0xa7b3f(%rip), %rax     # 0x2e2f6c
movq %rax, 0x569a34(%rip)    # 0x7a4e68
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x594f9c
testl %eax, %eax
je 0x23b487
leaq 0x286cba(%rip), %rax    # 0x4c213f
jmp 0x23b4b6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b49b
leaq 0x19c5ae(%rip), %rax    # 0x3d7a47
jmp 0x23b4b6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b4af
leaq 0x5e6c1(%rip), %rax     # 0x299b6e
jmp 0x23b4b6
leaq 0xaaa86(%rip), %rax     # 0x2e5f3c
movq %rax, 0x5699b3(%rip)    # 0x7a4e70
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x594f9c
testl %eax, %eax
je 0x23b510
leaq 0x28987a(%rip), %rax    # 0x4c4d88
jmp 0x23b53f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b524
leaq 0x19f1e5(%rip), %rax    # 0x3da707
jmp 0x23b53f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b538
leaq 0x5e638(%rip), %rax     # 0x299b6e
jmp 0x23b53f
leaq 0xadc1a(%rip), %rax     # 0x2e9159
movq %rax, 0x569932(%rip)    # 0x7a4e78
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