LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_64_pointer = parasail_sg_qe_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e3cd
leaq 0x26eaef(%rip), %rax    # 0x48ceba
jmp 0x21e3fc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e3e1
leaq 0x18aa36(%rip), %rax    # 0x3a8e15
jmp 0x21e3fc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e3f5
leaq 0x7b6c4(%rip), %rax     # 0x299ab7
jmp 0x21e3fc
leaq 0x945c7(%rip), %rax     # 0x2b29c3
movq %rax, 0x584fdd(%rip)    # 0x7a33e0
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_dispatch.c
// Function: parasail_sg_qe_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_32_pointer = parasail_sg_qe_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e456
leaq 0x270a6d(%rip), %rax    # 0x48eec1
jmp 0x21e485
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e46a
leaq 0x18c3b1(%rip), %rax    # 0x3aa819
jmp 0x21e485
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e47e
leaq 0x7b63b(%rip), %rax     # 0x299ab7
jmp 0x21e485
leaq 0x9625d(%rip), %rax     # 0x2b46e2
movq %rax, 0x584f5c(%rip)    # 0x7a33e8
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_dispatch.c
// Function: parasail_sg_qe_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_16_pointer = parasail_sg_qe_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e4df
leaq 0x272eae(%rip), %rax    # 0x49138b
jmp 0x21e50e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e4f3
leaq 0x18df70(%rip), %rax    # 0x3ac461
jmp 0x21e50e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e507
leaq 0x7b5b2(%rip), %rax     # 0x299ab7
jmp 0x21e50e
leaq 0x98033(%rip), %rax     # 0x2b6541
movq %rax, 0x584edb(%rip)    # 0x7a33f0
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_dispatch.c
// Function: parasail_sg_qe_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_8_pointer = parasail_sg_qe_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e568
leaq 0x2764db(%rip), %rax    # 0x494a41
jmp 0x21e597
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e57c
leaq 0x190391(%rip), %rax    # 0x3ae90b
jmp 0x21e597
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e590
leaq 0x7b529(%rip), %rax     # 0x299ab7
jmp 0x21e597
leaq 0x9a82c(%rip), %rax     # 0x2b8dc3
movq %rax, 0x584e5a(%rip)    # 0x7a33f8
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_dispatch.c
// Function: parasail_sg_qe_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_scan_64_pointer = parasail_sg_qe_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21e5f1
leaq 0x28028f(%rip), %rax    # 0x49e87e
jmp 0x21e620
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e605
leaq 0x199426(%rip), %rax    # 0x3b7a29
jmp 0x21e620
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e619
leaq 0x7c31e(%rip), %rax     # 0x29a935
jmp 0x21e620
leaq 0xa3d6b(%rip), %rax     # 0x2c238b
movq %rax, 0x584dd9(%rip)    # 0x7a3400
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_dispatch.c
// Function: parasail_sg_qe_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_scan_32_pointer = parasail_sg_qe_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21e67a
leaq 0x283669(%rip), %rax    # 0x4a1ce1
jmp 0x21e6a9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e68e
leaq 0x19c451(%rip), %rax    # 0x3baadd
jmp 0x21e6a9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e6a2
leaq 0x7c295(%rip), %rax     # 0x29a935
jmp 0x21e6a9
leaq 0xa73bf(%rip), %rax     # 0x2c5a68
movq %rax, 0x584d58(%rip)    # 0x7a3408
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_dispatch.c
// Function: parasail_sg_qe_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_scan_16_pointer = parasail_sg_qe_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21e703
leaq 0x28647c(%rip), %rax    # 0x4a4b7d
jmp 0x21e732
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e717
leaq 0x19f203(%rip), %rax    # 0x3bd918
jmp 0x21e732
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e72b
leaq 0x7c20c(%rip), %rax     # 0x29a935
jmp 0x21e732
leaq 0xaa60b(%rip), %rax     # 0x2c8d3d
movq %rax, 0x584cd7(%rip)    # 0x7a3410
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_dispatch.c
// Function: parasail_sg_qe_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_scan_8_pointer = parasail_sg_qe_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x21e78c
leaq 0x2892b5(%rip), %rax    # 0x4a7a3f
jmp 0x21e7bb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e7a0
leaq 0x1a2058(%rip), %rax    # 0x3c07f6
jmp 0x21e7bb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e7b4
leaq 0x7c183(%rip), %rax     # 0x29a935
jmp 0x21e7bb
leaq 0xada1b(%rip), %rax     # 0x2cc1d6
movq %rax, 0x584c56(%rip)    # 0x7a3418
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_dispatch.c
// Function: parasail_sg_qe_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_striped_64_pointer = parasail_sg_qe_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e815
leaq 0x29dcb7(%rip), %rax    # 0x4bc4ca
jmp 0x21e844
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e829
leaq 0x1b373f(%rip), %rax    # 0x3d1f66
jmp 0x21e844
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e83d
leaq 0x7b27c(%rip), %rax     # 0x299ab7
jmp 0x21e844
leaq 0xc1201(%rip), %rax     # 0x2dfa45
movq %rax, 0x584bd5(%rip)    # 0x7a3420
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_dispatch.c
// Function: parasail_sg_qe_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_striped_32_pointer = parasail_sg_qe_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e89e
leaq 0x2a0c3c(%rip), %rax    # 0x4bf4d8
jmp 0x21e8cd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e8b2
leaq 0x1b64c4(%rip), %rax    # 0x3d4d74
jmp 0x21e8cd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e8c6
leaq 0x7b1f3(%rip), %rax     # 0x299ab7
jmp 0x21e8cd
leaq 0xc45e8(%rip), %rax     # 0x2e2eb5
movq %rax, 0x584b54(%rip)    # 0x7a3428
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_dispatch.c
// Function: parasail_sg_qe_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_striped_16_pointer = parasail_sg_qe_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e927
leaq 0x2a3763(%rip), %rax    # 0x4c2088
jmp 0x21e956
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e93b
leaq 0x1b9057(%rip), %rax    # 0x3d7990
jmp 0x21e956
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e94f
leaq 0x7b16a(%rip), %rax     # 0x299ab7
jmp 0x21e956
leaq 0xc752f(%rip), %rax     # 0x2e5e85
movq %rax, 0x584ad3(%rip)    # 0x7a3430
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_dispatch.c
// Function: parasail_sg_qe_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_striped_8_pointer = parasail_sg_qe_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x21e9b0
leaq 0x2a6323(%rip), %rax    # 0x4c4cd1
jmp 0x21e9df
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21e9c4
leaq 0x1bbc8e(%rip), %rax    # 0x3da650
jmp 0x21e9df
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21e9d8
leaq 0x7b0e1(%rip), %rax     # 0x299ab7
jmp 0x21e9df
leaq 0xca6c3(%rip), %rax     # 0x2e90a2
movq %rax, 0x584a52(%rip)    # 0x7a3438
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_dispatch.c
// Function: parasail_sg_qe_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21ea39
leaq 0x28ca0d(%rip), %rax    # 0x4ab444
jmp 0x21ea68
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ea4d
leaq 0x1a5201(%rip), %rax    # 0x3c3c4c
jmp 0x21ea68
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ea61
leaq 0x7b058(%rip), %rax     # 0x299ab7
jmp 0x21ea68
leaq 0xb135e(%rip), %rax     # 0x2cfdc6
movq %rax, 0x5849d1(%rip)    # 0x7a3440
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_dispatch.c
// Function: parasail_sg_qe_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21eac2
leaq 0x290398(%rip), %rax    # 0x4aee58
jmp 0x21eaf1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ead6
leaq 0x1a844d(%rip), %rax    # 0x3c6f21
jmp 0x21eaf1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21eaea
leaq 0x7afcf(%rip), %rax     # 0x299ab7
jmp 0x21eaf1
leaq 0xb4ca6(%rip), %rax     # 0x2d3797
movq %rax, 0x584950(%rip)    # 0x7a3448
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_dispatch.c
// Function: parasail_sg_qe_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21eb4b
leaq 0x294248(%rip), %rax    # 0x4b2d91
jmp 0x21eb7a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21eb5f
leaq 0x1abb01(%rip), %rax    # 0x3ca65e
jmp 0x21eb7a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21eb73
leaq 0x7af46(%rip), %rax     # 0x299ab7
jmp 0x21eb7a
leaq 0xb8701(%rip), %rax     # 0x2d727b
movq %rax, 0x5848cf(%rip)    # 0x7a3450
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_dispatch.c
// Function: parasail_sg_qe_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21ebd4
leaq 0x29954b(%rip), %rax    # 0x4b811d
jmp 0x21ec03
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ebe8
leaq 0x1afb91(%rip), %rax    # 0x3ce777
jmp 0x21ec03
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ebfc
leaq 0x7aebd(%rip), %rax     # 0x299ab7
jmp 0x21ec03
leaq 0xbcedc(%rip), %rax     # 0x2dbadf
movq %rax, 0x58484e(%rip)    # 0x7a3458
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_dispatch.c
// Function: parasail_sg_qe_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21ec5d
leaq 0x2a9ce3(%rip), %rax    # 0x4c893e
jmp 0x21ec8c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ec71
leaq 0x1bddaa(%rip), %rax    # 0x3dca19
jmp 0x21ec8c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ec85
leaq 0x7bcb2(%rip), %rax     # 0x29a935
jmp 0x21ec8c
leaq 0xcd9f7(%rip), %rax     # 0x2ec683
movq %rax, 0x5847cd(%rip)    # 0x7a3460
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_dispatch.c
// Function: parasail_sg_qe_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21ece6
leaq 0x2abbf4(%rip), %rax    # 0x4ca8d8
jmp 0x21ed15
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ecfa
leaq 0x1bf6a6(%rip), %rax    # 0x3de39e
jmp 0x21ed15
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ed0e
leaq 0x7bc29(%rip), %rax     # 0x29a935
jmp 0x21ed15
leaq 0xcf554(%rip), %rax     # 0x2ee269
movq %rax, 0x58474c(%rip)    # 0x7a3468
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_dispatch.c
// Function: parasail_sg_qe_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21ed6f
leaq 0x2ada08(%rip), %rax    # 0x4cc775
jmp 0x21ed9e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ed83
leaq 0x1c10dc(%rip), %rax    # 0x3dfe5d
jmp 0x21ed9e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ed97
leaq 0x7bba0(%rip), %rax     # 0x29a935
jmp 0x21ed9e
leaq 0xd1099(%rip), %rax     # 0x2efe37
movq %rax, 0x5846cb(%rip)    # 0x7a3470
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_dispatch.c
// Function: parasail_sg_qe_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21edf8
leaq 0x2afd27(%rip), %rax    # 0x4ceb1d
jmp 0x21ee27
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ee0c
leaq 0x1c2f15(%rip), %rax    # 0x3e1d1f
jmp 0x21ee27
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ee20
leaq 0x7bb17(%rip), %rax     # 0x29a935
jmp 0x21ee27
leaq 0xd31da(%rip), %rax     # 0x2f2001
movq %rax, 0x58464a(%rip)    # 0x7a3478
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_dispatch.c
// Function: parasail_sg_qe_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_striped_64_pointer = parasail_sg_qe_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x21ee81
leaq 0x2c1077(%rip), %rax    # 0x4dfef6
jmp 0x21eeb0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ee95
leaq 0x1cebc5(%rip), %rax    # 0x3eda58
jmp 0x21eeb0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21eea9
leaq 0x7ac10(%rip), %rax     # 0x299ab7
jmp 0x21eeb0
leaq 0xdff0c(%rip), %rax     # 0x2fedbc
movq %rax, 0x5845c9(%rip)    # 0x7a3480
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_dispatch.c
// Function: parasail_sg_qe_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_striped_32_pointer = parasail_sg_qe_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x21ef0a
leaq 0x2c2bcb(%rip), %rax    # 0x4e1ad3
jmp 0x21ef39
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ef1e
leaq 0x1d0362(%rip), %rax    # 0x3ef27e
jmp 0x21ef39
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ef32
leaq 0x7ab87(%rip), %rax     # 0x299ab7
jmp 0x21ef39
leaq 0xe18f6(%rip), %rax     # 0x30082f
movq %rax, 0x584548(%rip)    # 0x7a3488
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