LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_diag_16_pointer = parasail_sg_qx_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224767
leaq 0x295c43(%rip), %rax    # 0x4ba3a8
jmp 0x224796
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22477b
leaq 0x1a7ed9(%rip), %rax    # 0x3cc652
jmp 0x224796
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22478f
leaq 0x76913(%rip), %rax     # 0x29b0a0
jmp 0x224796
leaq 0x972da(%rip), %rax     # 0x2bba70
movq %rax, 0x5b50b3(%rip)    # 0x7d9850
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_diag_8_pointer = parasail_sg_qx_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2247f0
leaq 0x298b0f(%rip), %rax    # 0x4bd2fd
jmp 0x22481f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224804
leaq 0x1aa1cb(%rip), %rax    # 0x3ce9cd
jmp 0x22481f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224818
leaq 0x7688a(%rip), %rax     # 0x29b0a0
jmp 0x22481f
leaq 0x99c0d(%rip), %rax     # 0x2be42c
movq %rax, 0x5b5032(%rip)    # 0x7d9858
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224879
leaq 0x2a37f0(%rip), %rax    # 0x4c8067
jmp 0x2248a8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22488d
leaq 0x1b3c58(%rip), %rax    # 0x3d84e3
jmp 0x2248a8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2248a1
leaq 0x77afd(%rip), %rax     # 0x29c39c
jmp 0x2248a8
leaq 0xa539c(%rip), %rax     # 0x2c9c44
movq %rax, 0x5b4fb1(%rip)    # 0x7d9860
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224902
leaq 0x2a66f5(%rip), %rax    # 0x4caff5
jmp 0x224931
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224916
leaq 0x1b6c82(%rip), %rax    # 0x3db596
jmp 0x224931
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22492a
leaq 0x77a74(%rip), %rax     # 0x29c39c
jmp 0x224931
leaq 0xa8c40(%rip), %rax     # 0x2cd571
movq %rax, 0x5b4f30(%rip)    # 0x7d9868
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22498b
leaq 0x2a9e38(%rip), %rax    # 0x4ce7c1
jmp 0x2249ba
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22499f
leaq 0x1ba045(%rip), %rax    # 0x3de9e2
jmp 0x2249ba
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2249b3
leaq 0x779eb(%rip), %rax     # 0x29c39c
jmp 0x2249ba
leaq 0xac7e9(%rip), %rax     # 0x2d11a3
movq %rax, 0x5b4eaf(%rip)    # 0x7d9870
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224a14
leaq 0x2ae0a9(%rip), %rax    # 0x4d2abb
jmp 0x224a43
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224a28
leaq 0x1bd845(%rip), %rax    # 0x3e226b
jmp 0x224a43
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224a3c
leaq 0x77962(%rip), %rax     # 0x29c39c
jmp 0x224a43
leaq 0xb0ce3(%rip), %rax     # 0x2d5726
movq %rax, 0x5b4e2e(%rip)    # 0x7d9878
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224a9d
leaq 0x2c10d0(%rip), %rax    # 0x4e5b6b
jmp 0x224acc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224ab1
leaq 0x1ce7f9(%rip), %rax    # 0x3f32a8
jmp 0x224acc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224ac5
leaq 0x765dd(%rip), %rax     # 0x29b0a0
jmp 0x224acc
leaq 0xc4f0d(%rip), %rax     # 0x2e99d9
movq %rax, 0x5b4dad(%rip)    # 0x7d9880
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224b26
leaq 0x2c3d83(%rip), %rax    # 0x4e88a7
jmp 0x224b55
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224b3a
leaq 0x1d15f0(%rip), %rax    # 0x3f6128
jmp 0x224b55
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224b4e
leaq 0x76554(%rip), %rax     # 0x29b0a0
jmp 0x224b55
leaq 0xc8843(%rip), %rax     # 0x2ed398
movq %rax, 0x5b4d2c(%rip)    # 0x7d9888
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224baf
leaq 0x2c7490(%rip), %rax    # 0x4ec03d
jmp 0x224bde
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224bc3
leaq 0x1d4778(%rip), %rax    # 0x3f9339
jmp 0x224bde
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224bd7
leaq 0x764cb(%rip), %rax     # 0x29b0a0
jmp 0x224bde
leaq 0xcbeef(%rip), %rax     # 0x2f0acd
movq %rax, 0x5b4cab(%rip)    # 0x7d9890
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224c38
leaq 0x2cbb1e(%rip), %rax    # 0x4f0754
jmp 0x224c67
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224c4c
leaq 0x1d7ced(%rip), %rax    # 0x3fc937
jmp 0x224c67
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224c60
leaq 0x76442(%rip), %rax     # 0x29b0a0
jmp 0x224c67
leaq 0xcff8c(%rip), %rax     # 0x2f4bf3
movq %rax, 0x5b4c2a(%rip)    # 0x7d9898
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224cc1
leaq 0x2b11db(%rip), %rax    # 0x4d5e9a
jmp 0x224cf0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224cd5
leaq 0x1c0806(%rip), %rax    # 0x3e54d9
jmp 0x224cf0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224ce9
leaq 0x763b9(%rip), %rax     # 0x29b0a0
jmp 0x224cf0
leaq 0xb47f7(%rip), %rax     # 0x2d94e7
movq %rax, 0x5b4ba9(%rip)    # 0x7d98a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224d4a
leaq 0x2b4753(%rip), %rax    # 0x4d949b
jmp 0x224d79
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224d5e
leaq 0x1c38e2(%rip), %rax    # 0x3e863e
jmp 0x224d79
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224d72
leaq 0x76330(%rip), %rax     # 0x29b0a0
jmp 0x224d79
leaq 0xb81fe(%rip), %rax     # 0x2dcf77
movq %rax, 0x5b4b28(%rip)    # 0x7d98a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224dd3
leaq 0x2b869e(%rip), %rax    # 0x4dd46f
jmp 0x224e02
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224de7
leaq 0x1c6f64(%rip), %rax    # 0x3ebd49
jmp 0x224e02
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224dfb
leaq 0x762a7(%rip), %rax     # 0x29b0a0
jmp 0x224e02
leaq 0xbbb93(%rip), %rax     # 0x2e0995
movq %rax, 0x5b4aa7(%rip)    # 0x7d98b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224e5c
leaq 0x2bd429(%rip), %rax    # 0x4e2283
jmp 0x224e8b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224e70
leaq 0x1caf77(%rip), %rax    # 0x3efde5
jmp 0x224e8b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224e84
leaq 0x7621e(%rip), %rax     # 0x29b0a0
jmp 0x224e8b
leaq 0xc0738(%rip), %rax     # 0x2e55c3
movq %rax, 0x5b4a26(%rip)    # 0x7d98b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224ee5
leaq 0x2cecf3(%rip), %rax    # 0x4f3bd6
jmp 0x224f14
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224ef9
leaq 0x1d9cab(%rip), %rax    # 0x3feba2
jmp 0x224f14
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224f0d
leaq 0x77491(%rip), %rax     # 0x29c39c
jmp 0x224f14
leaq 0xd3818(%rip), %rax     # 0x2f872c
movq %rax, 0x5b49a5(%rip)    # 0x7d98c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224f6e
leaq 0x2d092d(%rip), %rax    # 0x4f5899
jmp 0x224f9d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x224f82
leaq 0x1db7b9(%rip), %rax    # 0x400739
jmp 0x224f9d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x224f96
leaq 0x77408(%rip), %rax     # 0x29c39c
jmp 0x224f9d
leaq 0xd57eb(%rip), %rax     # 0x2fa788
movq %rax, 0x5b4924(%rip)    # 0x7d98c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x224ff7
leaq 0x2d3483(%rip), %rax    # 0x4f8478
jmp 0x225026
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22500b
leaq 0x1dd773(%rip), %rax    # 0x40277c
jmp 0x225026
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22501f
leaq 0x7737f(%rip), %rax     # 0x29c39c
jmp 0x225026
leaq 0xd7bf4(%rip), %rax     # 0x2fcc1a
movq %rax, 0x5b48a3(%rip)    # 0x7d98d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225080
leaq 0x2d7296(%rip), %rax    # 0x4fc314
jmp 0x2250af
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225094
leaq 0x1dfee3(%rip), %rax    # 0x404f75
jmp 0x2250af
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2250a8
leaq 0x772f6(%rip), %rax     # 0x29c39c
jmp 0x2250af
leaq 0xdacb6(%rip), %rax     # 0x2ffd65
movq %rax, 0x5b4822(%rip)    # 0x7d98d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x5c8fdb
testl %eax, %eax
je 0x225109
leaq 0x2e6ba1(%rip), %rax    # 0x50bca8
jmp 0x225138
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22511d
leaq 0x1eb40e(%rip), %rax    # 0x410529
jmp 0x225138
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225131
leaq 0x75f71(%rip), %rax     # 0x29b0a0
jmp 0x225138
leaq 0xe7e3b(%rip), %rax     # 0x30cf73
movq %rax, 0x5b47a1(%rip)    # 0x7d98e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x5c8fdb
testl %eax, %eax
je 0x225192
leaq 0x2e85b8(%rip), %rax    # 0x50d748
jmp 0x2251c1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2251a6
leaq 0x1ecc79(%rip), %rax    # 0x411e1d
jmp 0x2251c1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2251ba
leaq 0x75ee8(%rip), %rax     # 0x29b0a0
jmp 0x2251c1
leaq 0xe9b8c(%rip), %rax     # 0x30ed4d
movq %rax, 0x5b4720(%rip)    # 0x7d98e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_table_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_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22521b
leaq 0x2eb164(%rip), %rax    # 0x51037d
jmp 0x22524a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22522f
leaq 0x1eeb4d(%rip), %rax    # 0x413d7a
jmp 0x22524a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225243
leaq 0x75e5f(%rip), %rax     # 0x29b0a0
jmp 0x22524a
leaq 0xebe58(%rip), %rax     # 0x3110a2
movq %rax, 0x5b469f(%rip)    # 0x7d98f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_table_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_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2252a4
leaq 0x2ef1d6(%rip), %rax    # 0x514478
jmp 0x2252d3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2252b8
leaq 0x1f143a(%rip), %rax    # 0x4166f0
jmp 0x2252d3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2252cc
leaq 0x75dd6(%rip), %rax     # 0x29b0a0
jmp 0x2252d3
leaq 0xef023(%rip), %rax     # 0x3142f6
movq %rax, 0x5b461e(%rip)    # 0x7d98f8
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