LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_16_pointer = parasail_sg_qe_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c0f0f
leaq 0x2a824f(%rip), %rax    # 0x46915c
jmp 0x1c0f3e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c0f23
leaq 0x1b3449(%rip), %rax    # 0x37436a
jmp 0x1c0f3e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c0f37
leaq 0x7b927(%rip), %rax     # 0x23c85c
jmp 0x1c0f3e
leaq 0xa4edf(%rip), %rax     # 0x265e1d
movq %rax, 0x57b48b(%rip)    # 0x73c3d0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_8_pointer = parasail_sg_qe_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c0f98
leaq 0x2a9b52(%rip), %rax    # 0x46aae8
jmp 0x1c0fc7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c0fac
leaq 0x1b4d1d(%rip), %rax    # 0x375cc7
jmp 0x1c0fc7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c0fc0
leaq 0x7b89e(%rip), %rax     # 0x23c85c
jmp 0x1c0fc7
leaq 0xa6aba(%rip), %rax     # 0x267a81
movq %rax, 0x57b40a(%rip)    # 0x73c3d8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1021
leaq 0x29b143(%rip), %rax    # 0x45c162
jmp 0x1c1050
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1035
leaq 0x1a80d3(%rip), %rax    # 0x369106
jmp 0x1c1050
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1049
leaq 0x7b815(%rip), %rax     # 0x23c85c
jmp 0x1c1050
leaq 0x97fde(%rip), %rax     # 0x25902e
movq %rax, 0x57b389(%rip)    # 0x73c3e0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c10aa
leaq 0x29d04c(%rip), %rax    # 0x45e0f4
jmp 0x1c10d9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c10be
leaq 0x1a9bb3(%rip), %rax    # 0x36ac6f
jmp 0x1c10d9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c10d2
leaq 0x7b78c(%rip), %rax     # 0x23c85c
jmp 0x1c10d9
leaq 0x99f18(%rip), %rax     # 0x25aff1
movq %rax, 0x57b308(%rip)    # 0x73c3e8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1133
leaq 0x29f52c(%rip), %rax    # 0x46065d
jmp 0x1c1162
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1147
leaq 0x1ab811(%rip), %rax    # 0x36c956
jmp 0x1c1162
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c115b
leaq 0x7b703(%rip), %rax     # 0x23c85c
jmp 0x1c1162
leaq 0x9be98(%rip), %rax     # 0x25cffa
movq %rax, 0x57b287(%rip)    # 0x73c3f0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c11bc
leaq 0x2a2539(%rip), %rax    # 0x4636f3
jmp 0x1c11eb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c11d0
leaq 0x1adbf2(%rip), %rax    # 0x36edc0
jmp 0x1c11eb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c11e4
leaq 0x7b67a(%rip), %rax     # 0x23c85c
jmp 0x1c11eb
leaq 0x9ea44(%rip), %rax     # 0x25fc2f
movq %rax, 0x57b206(%rip)    # 0x73c3f8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1245
leaq 0x2acee8(%rip), %rax    # 0x46e12b
jmp 0x1c1274
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1259
leaq 0x1b851f(%rip), %rax    # 0x379776
jmp 0x1c1274
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c126d
leaq 0x7c65f(%rip), %rax     # 0x23d8ca
jmp 0x1c1274
leaq 0xaa5bf(%rip), %rax     # 0x26b833
movq %rax, 0x57b185(%rip)    # 0x73c400
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c12ce
leaq 0x2b0608(%rip), %rax    # 0x4718d4
jmp 0x1c12fd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c12e2
leaq 0x1bbb41(%rip), %rax    # 0x37ce21
jmp 0x1c12fd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c12f6
leaq 0x7c5d6(%rip), %rax     # 0x23d8ca
jmp 0x1c12fd
leaq 0xae517(%rip), %rax     # 0x26f814
movq %rax, 0x57b104(%rip)    # 0x73c408
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1357
leaq 0x2b38b0(%rip), %rax    # 0x474c05
jmp 0x1c1386
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c136b
leaq 0x1bee03(%rip), %rax    # 0x38016c
jmp 0x1c1386
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c137f
leaq 0x7c54d(%rip), %rax     # 0x23d8ca
jmp 0x1c1386
leaq 0xb1c5f(%rip), %rax     # 0x272fe5
movq %rax, 0x57b083(%rip)    # 0x73c410
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c13e0
leaq 0x2b6b5b(%rip), %rax    # 0x477f39
jmp 0x1c140f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c13f4
leaq 0x1c2129(%rip), %rax    # 0x38351b
jmp 0x1c140f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1408
leaq 0x7c4c4(%rip), %rax     # 0x23d8ca
jmp 0x1c140f
leaq 0xb5535(%rip), %rax     # 0x276944
movq %rax, 0x57b002(%rip)    # 0x73c418
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1469
leaq 0x2cab17(%rip), %rax    # 0x48bf7e
jmp 0x1c1498
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c147d
leaq 0x1d4305(%rip), %rax    # 0x395780
jmp 0x1c1498
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1491
leaq 0x7b3cd(%rip), %rax     # 0x23c85c
jmp 0x1c1498
leaq 0xca6ae(%rip), %rax     # 0x28bb46
movq %rax, 0x57af81(%rip)    # 0x73c420
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c14f2
leaq 0x2cdeaa(%rip), %rax    # 0x48f39a
jmp 0x1c1521
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1506
leaq 0x1d775f(%rip), %rax    # 0x398c63
jmp 0x1c1521
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c151a
leaq 0x7b344(%rip), %rax     # 0x23c85c
jmp 0x1c1521
leaq 0xce367(%rip), %rax     # 0x28f888
movq %rax, 0x57af00(%rip)    # 0x73c428
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c157b
leaq 0x2d0f5c(%rip), %rax    # 0x4924d5
jmp 0x1c15aa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c158f
leaq 0x1da962(%rip), %rax    # 0x39beef
jmp 0x1c15aa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c15a3
leaq 0x7b2bb(%rip), %rax     # 0x23c85c
jmp 0x1c15aa
leaq 0xd18da(%rip), %rax     # 0x292e84
movq %rax, 0x57ae7f(%rip)    # 0x73c430
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1604
leaq 0x2d4100(%rip), %rax    # 0x495702
jmp 0x1c1633
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1618
leaq 0x1ddbb1(%rip), %rax    # 0x39f1c7
jmp 0x1c1633
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c162c
leaq 0x7b232(%rip), %rax     # 0x23c85c
jmp 0x1c1633
leaq 0xd5093(%rip), %rax     # 0x2966c6
movq %rax, 0x57adfe(%rip)    # 0x73c438
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c168d
leaq 0x2ba252(%rip), %rax    # 0x47b8dd
jmp 0x1c16bc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c16a1
leaq 0x1c5751(%rip), %rax    # 0x386df0
jmp 0x1c16bc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c16b5
leaq 0x7b1a9(%rip), %rax     # 0x23c85c
jmp 0x1c16bc
leaq 0xb95ec(%rip), %rax     # 0x27aca8
movq %rax, 0x57ad7d(%rip)    # 0x73c440
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1716
leaq 0x2bd912(%rip), %rax    # 0x47f026
jmp 0x1c1745
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c172a
leaq 0x1c8c42(%rip), %rax    # 0x38a36a
jmp 0x1c1745
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c173e
leaq 0x7b120(%rip), %rax     # 0x23c85c
jmp 0x1c1745
leaq 0xbd259(%rip), %rax     # 0x27e99e
movq %rax, 0x57acfc(%rip)    # 0x73c448
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c179f
leaq 0x2c17ee(%rip), %rax    # 0x482f8b
jmp 0x1c17ce
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c17b3
leaq 0x1cc2a8(%rip), %rax    # 0x38da59
jmp 0x1c17ce
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c17c7
leaq 0x7b097(%rip), %rax     # 0x23c85c
jmp 0x1c17ce
leaq 0xc0c5c(%rip), %rax     # 0x28242a
movq %rax, 0x57ac7b(%rip)    # 0x73c450
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1828
leaq 0x2c6591(%rip), %rax    # 0x487db7
jmp 0x1c1857
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c183c
leaq 0x1d01e1(%rip), %rax    # 0x391a1b
jmp 0x1c1857
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1850
leaq 0x7b00e(%rip), %rax     # 0x23c85c
jmp 0x1c1857
leaq 0xc5783(%rip), %rax     # 0x286fda
movq %rax, 0x57abfa(%rip)    # 0x73c458
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c18b1
leaq 0x2d7e98(%rip), %rax    # 0x499747
jmp 0x1c18e0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c18c5
leaq 0x1e0024(%rip), %rax    # 0x3a18e7
jmp 0x1c18e0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c18d9
leaq 0x7bff3(%rip), %rax     # 0x23d8ca
jmp 0x1c18e0
leaq 0xd90ab(%rip), %rax     # 0x29a98b
movq %rax, 0x57ab79(%rip)    # 0x73c460
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c193a
leaq 0x2d9d96(%rip), %rax    # 0x49b6ce
jmp 0x1c1969
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c194e
leaq 0x1e1c6e(%rip), %rax    # 0x3a35ba
jmp 0x1c1969
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1962
leaq 0x7bf6a(%rip), %rax     # 0x23d8ca
jmp 0x1c1969
leaq 0xdb1ab(%rip), %rax     # 0x29cb14
movq %rax, 0x57aaf8(%rip)    # 0x73c468
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c19c3
leaq 0x2dbefd(%rip), %rax    # 0x49d8be
jmp 0x1c19f2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c19d7
leaq 0x1e3aa4(%rip), %rax    # 0x3a5479
jmp 0x1c19f2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c19eb
leaq 0x7bee1(%rip), %rax     # 0x23d8ca
jmp 0x1c19f2
leaq 0xdd12a(%rip), %rax     # 0x29eb1c
movq %rax, 0x57aa77(%rip)    # 0x73c470
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c1a4c
leaq 0x2de507(%rip), %rax    # 0x49ff51
jmp 0x1c1a7b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1a60
leaq 0x1e5b8f(%rip), %rax    # 0x3a75ed
jmp 0x1c1a7b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1a74
leaq 0x7be58(%rip), %rax     # 0x23d8ca
jmp 0x1c1a7b
leaq 0xdf649(%rip), %rax     # 0x2a10c4
movq %rax, 0x57a9f6(%rip)    # 0x73c478
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