LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x5672cf
testl %eax, %eax
je 0x1c6294
leaq 0x2cf48c(%rip), %rax    # 0x49571e
jmp 0x1c62c3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c62a8
leaq 0x1d8f3d(%rip), %rax    # 0x39f1e3
jmp 0x1c62c3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c62bc
leaq 0x765be(%rip), %rax     # 0x23c878
jmp 0x1c62c3
leaq 0xd041f(%rip), %rax     # 0x2966e2
movq %rax, 0x5765ce(%rip)    # 0x73c898
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_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 0x5672cf
testl %eax, %eax
je 0x1c631d
leaq 0x2b55de(%rip), %rax    # 0x47b8f9
jmp 0x1c634c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6331
leaq 0x1c0add(%rip), %rax    # 0x386e0c
jmp 0x1c634c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6345
leaq 0x76535(%rip), %rax     # 0x23c878
jmp 0x1c634c
leaq 0xb4978(%rip), %rax     # 0x27acc4
movq %rax, 0x57654d(%rip)    # 0x73c8a0
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_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 0x5672cf
testl %eax, %eax
je 0x1c63a6
leaq 0x2b8c9e(%rip), %rax    # 0x47f042
jmp 0x1c63d5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c63ba
leaq 0x1c3fce(%rip), %rax    # 0x38a386
jmp 0x1c63d5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c63ce
leaq 0x764ac(%rip), %rax     # 0x23c878
jmp 0x1c63d5
leaq 0xb85e5(%rip), %rax     # 0x27e9ba
movq %rax, 0x5764cc(%rip)    # 0x73c8a8
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_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 0x5672cf
testl %eax, %eax
je 0x1c642f
leaq 0x2bcb7a(%rip), %rax    # 0x482fa7
jmp 0x1c645e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6443
leaq 0x1c7634(%rip), %rax    # 0x38da75
jmp 0x1c645e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6457
leaq 0x76423(%rip), %rax     # 0x23c878
jmp 0x1c645e
leaq 0xbbfe8(%rip), %rax     # 0x282446
movq %rax, 0x57644b(%rip)    # 0x73c8b0
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_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 0x5672cf
testl %eax, %eax
je 0x1c64b8
leaq 0x2c191d(%rip), %rax    # 0x487dd3
jmp 0x1c64e7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c64cc
leaq 0x1cb56d(%rip), %rax    # 0x391a37
jmp 0x1c64e7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c64e0
leaq 0x7639a(%rip), %rax     # 0x23c878
jmp 0x1c64e7
leaq 0xc0b0f(%rip), %rax     # 0x286ff6
movq %rax, 0x5763ca(%rip)    # 0x73c8b8
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_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 0x5672cf
testl %eax, %eax
je 0x1c6541
leaq 0x2d3224(%rip), %rax    # 0x499763
jmp 0x1c6570
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6555
leaq 0x1db3b0(%rip), %rax    # 0x3a1903
jmp 0x1c6570
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6569
leaq 0x7737f(%rip), %rax     # 0x23d8e6
jmp 0x1c6570
leaq 0xd4437(%rip), %rax     # 0x29a9a7
movq %rax, 0x576349(%rip)    # 0x73c8c0
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_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 0x5672cf
testl %eax, %eax
je 0x1c65ca
leaq 0x2d5122(%rip), %rax    # 0x49b6ea
jmp 0x1c65f9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c65de
leaq 0x1dcffa(%rip), %rax    # 0x3a35d6
jmp 0x1c65f9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c65f2
leaq 0x772f6(%rip), %rax     # 0x23d8e6
jmp 0x1c65f9
leaq 0xd6537(%rip), %rax     # 0x29cb30
movq %rax, 0x5762c8(%rip)    # 0x73c8c8
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_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 0x5672cf
testl %eax, %eax
je 0x1c6653
leaq 0x2d7289(%rip), %rax    # 0x49d8da
jmp 0x1c6682
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6667
leaq 0x1dee30(%rip), %rax    # 0x3a5495
jmp 0x1c6682
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c667b
leaq 0x7726d(%rip), %rax     # 0x23d8e6
jmp 0x1c6682
leaq 0xd84b6(%rip), %rax     # 0x29eb38
movq %rax, 0x576247(%rip)    # 0x73c8d0
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_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 0x5672cf
testl %eax, %eax
je 0x1c66dc
leaq 0x2d9893(%rip), %rax    # 0x49ff6d
jmp 0x1c670b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c66f0
leaq 0x1e0f1b(%rip), %rax    # 0x3a7609
jmp 0x1c670b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6704
leaq 0x771e4(%rip), %rax     # 0x23d8e6
jmp 0x1c670b
leaq 0xda9d5(%rip), %rax     # 0x2a10e0
movq %rax, 0x5761c6(%rip)    # 0x73c8d8
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_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 0x5672cf
testl %eax, %eax
je 0x1c6765
leaq 0x2eafb8(%rip), %rax    # 0x4b171b
jmp 0x1c6794
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6779
leaq 0x1ed81d(%rip), %rax    # 0x3b3f94
jmp 0x1c6794
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c678d
leaq 0x760ed(%rip), %rax     # 0x23c878
jmp 0x1c6794
leaq 0xe8fd9(%rip), %rax     # 0x2af76d
movq %rax, 0x576145(%rip)    # 0x73c8e0
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_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 0x5672cf
testl %eax, %eax
je 0x1c67ee
leaq 0x2ed036(%rip), %rax    # 0x4b3822
jmp 0x1c681d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6802
leaq 0x1ef712(%rip), %rax    # 0x3b5f12
jmp 0x1c681d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6816
leaq 0x76064(%rip), %rax     # 0x23c878
jmp 0x1c681d
leaq 0xeb280(%rip), %rax     # 0x2b1a9d
movq %rax, 0x5760c4(%rip)    # 0x73c8e8
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_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 0x5672cf
testl %eax, %eax
je 0x1c6877
leaq 0x2ef354(%rip), %rax    # 0x4b5bc9
jmp 0x1c68a6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c688b
leaq 0x1f171c(%rip), %rax    # 0x3b7fa5
jmp 0x1c68a6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c689f
leaq 0x75fdb(%rip), %rax     # 0x23c878
jmp 0x1c68a6
leaq 0xed388(%rip), %rax     # 0x2b3c2e
movq %rax, 0x576043(%rip)    # 0x73c8f0
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_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 0x5672cf
testl %eax, %eax
je 0x1c6900
leaq 0x2f1c58(%rip), %rax    # 0x4b8556
jmp 0x1c692f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6914
leaq 0x1f3a01(%rip), %rax    # 0x3ba313
jmp 0x1c692f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6928
leaq 0x75f52(%rip), %rax     # 0x23c878
jmp 0x1c692f
leaq 0xef85e(%rip), %rax     # 0x2b618d
movq %rax, 0x575fc2(%rip)    # 0x73c8f8
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_table_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_table_diag_64_pointer = parasail_sg_qx_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_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 0x1c6989
leaq 0x2dbd3a(%rip), %rax    # 0x4a26c1
jmp 0x1c69b8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c699d
leaq 0x1e2dc0(%rip), %rax    # 0x3a975b
jmp 0x1c69b8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c69b1
leaq 0x75ec9(%rip), %rax     # 0x23c878
jmp 0x1c69b8
leaq 0xdd05d(%rip), %rax     # 0x2a3a15
movq %rax, 0x575f41(%rip)    # 0x73c900
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_table_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_table_diag_32_pointer = parasail_sg_qx_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_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 0x1c6a12
leaq 0x2de505(%rip), %rax    # 0x4a4f15
jmp 0x1c6a41
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6a26
leaq 0x1e4c63(%rip), %rax    # 0x3ab687
jmp 0x1c6a41
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6a3a
leaq 0x75e40(%rip), %rax     # 0x23c878
jmp 0x1c6a41
leaq 0xdf322(%rip), %rax     # 0x2a5d63
movq %rax, 0x575ec0(%rip)    # 0x73c908
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_table_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_table_diag_16_pointer = parasail_sg_qx_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_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 0x1c6a9b
leaq 0x2e1c63(%rip), %rax    # 0x4a86fc
jmp 0x1c6aca
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6aaf
leaq 0x1e721c(%rip), %rax    # 0x3adcc9
jmp 0x1c6aca
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6ac3
leaq 0x75db7(%rip), %rax     # 0x23c878
jmp 0x1c6aca
leaq 0xe1c53(%rip), %rax     # 0x2a871d
movq %rax, 0x575e3f(%rip)    # 0x73c910
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_table_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_table_diag_8_pointer = parasail_sg_qx_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_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 0x1c6b24
leaq 0x2e746f(%rip), %rax    # 0x4adf91
jmp 0x1c6b53
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6b38
leaq 0x1ea94f(%rip), %rax    # 0x3b1485
jmp 0x1c6b53
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6b4c
leaq 0x75d2e(%rip), %rax     # 0x23c878
jmp 0x1c6b53
leaq 0xe5a0b(%rip), %rax     # 0x2ac55e
movq %rax, 0x575dbe(%rip)    # 0x73c918
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_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 0x1c6bad
leaq 0x2f587f(%rip), %rax    # 0x4bc42a
jmp 0x1c6bdc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6bc1
leaq 0x1f791d(%rip), %rax    # 0x3be4dc
jmp 0x1c6bdc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6bd5
leaq 0x76d13(%rip), %rax     # 0x23d8e6
jmp 0x1c6bdc
leaq 0xf3905(%rip), %rax     # 0x2ba4e1
movq %rax, 0x575d3d(%rip)    # 0x73c920
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_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 0x1c6c36
leaq 0x2f9675(%rip), %rax    # 0x4c02a9
jmp 0x1c6c65
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6c4a
leaq 0x1fb405(%rip), %rax    # 0x3c204d
jmp 0x1c6c65
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6c5e
leaq 0x76c8a(%rip), %rax     # 0x23d8e6
jmp 0x1c6c65
leaq 0xf7d7f(%rip), %rax     # 0x2be9e4
movq %rax, 0x575cbc(%rip)    # 0x73c928
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_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 0x1c6cbf
leaq 0x2fd3e4(%rip), %rax    # 0x4c40a1
jmp 0x1c6cee
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6cd3
leaq 0x1fee33(%rip), %rax    # 0x3c5b04
jmp 0x1c6cee
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6ce7
leaq 0x76c01(%rip), %rax     # 0x23d8e6
jmp 0x1c6cee
leaq 0xfbc6f(%rip), %rax     # 0x2c295d
movq %rax, 0x575c3b(%rip)    # 0x73c930
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_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 0x1c6d48
leaq 0x3016ea(%rip), %rax    # 0x4c8430
jmp 0x1c6d77
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6d5c
leaq 0x202b61(%rip), %rax    # 0x3c98bb
jmp 0x1c6d77
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6d70
leaq 0x76b78(%rip), %rax     # 0x23d8e6
jmp 0x1c6d77
leaq 0xffe8e(%rip), %rax     # 0x2c6c05
movq %rax, 0x575bba(%rip)    # 0x73c938
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_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 0x5672cf
testl %eax, %eax
je 0x1c6dd1
leaq 0x31a9d9(%rip), %rax    # 0x4e17a8
jmp 0x1c6e00
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6de5
leaq 0x21800a(%rip), %rax    # 0x3deded
jmp 0x1c6e00
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6df9
leaq 0x75a81(%rip), %rax     # 0x23c878
jmp 0x1c6e00
leaq 0x11814d(%rip), %rax    # 0x2def4d
movq %rax, 0x575b39(%rip)    # 0x73c940
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