LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219c0e
leaq 0x2a58b1(%rip), %rax    # 0x4bf4bd
jmp 0x219c3d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219c22
leaq 0x1bb139(%rip), %rax    # 0x3d4d59
jmp 0x219c3d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219c36
leaq 0x7fe68(%rip), %rax     # 0x299a9c
jmp 0x219c3d
leaq 0xc925d(%rip), %rax     # 0x2e2e9a
movq %rax, 0x589384(%rip)    # 0x7a2fc8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219c97
leaq 0x2a83d8(%rip), %rax    # 0x4c206d
jmp 0x219cc6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219cab
leaq 0x1bdccc(%rip), %rax    # 0x3d7975
jmp 0x219cc6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219cbf
leaq 0x7fddf(%rip), %rax     # 0x299a9c
jmp 0x219cc6
leaq 0xcc1a4(%rip), %rax     # 0x2e5e6a
movq %rax, 0x589303(%rip)    # 0x7a2fd0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219d20
leaq 0x2aaf98(%rip), %rax    # 0x4c4cb6
jmp 0x219d4f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219d34
leaq 0x1c0903(%rip), %rax    # 0x3da635
jmp 0x219d4f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219d48
leaq 0x7fd56(%rip), %rax     # 0x299a9c
jmp 0x219d4f
leaq 0xcf338(%rip), %rax     # 0x2e9087
movq %rax, 0x589282(%rip)    # 0x7a2fd8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219da9
leaq 0x291682(%rip), %rax    # 0x4ab429
jmp 0x219dd8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219dbd
leaq 0x1a9e76(%rip), %rax    # 0x3c3c31
jmp 0x219dd8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219dd1
leaq 0x7fccd(%rip), %rax     # 0x299a9c
jmp 0x219dd8
leaq 0xb5fd3(%rip), %rax     # 0x2cfdab
movq %rax, 0x589201(%rip)    # 0x7a2fe0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219e32
leaq 0x29500d(%rip), %rax    # 0x4aee3d
jmp 0x219e61
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219e46
leaq 0x1ad0c2(%rip), %rax    # 0x3c6f06
jmp 0x219e61
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219e5a
leaq 0x7fc44(%rip), %rax     # 0x299a9c
jmp 0x219e61
leaq 0xb991b(%rip), %rax     # 0x2d377c
movq %rax, 0x589180(%rip)    # 0x7a2fe8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219ebb
leaq 0x298ebd(%rip), %rax    # 0x4b2d76
jmp 0x219eea
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219ecf
leaq 0x1b0776(%rip), %rax    # 0x3ca643
jmp 0x219eea
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219ee3
leaq 0x7fbbb(%rip), %rax     # 0x299a9c
jmp 0x219eea
leaq 0xbd376(%rip), %rax     # 0x2d7260
movq %rax, 0x5890ff(%rip)    # 0x7a2ff0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219f44
leaq 0x29e1c0(%rip), %rax    # 0x4b8102
jmp 0x219f73
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219f58
leaq 0x1b4806(%rip), %rax    # 0x3ce75c
jmp 0x219f73
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219f6c
leaq 0x7fb32(%rip), %rax     # 0x299a9c
jmp 0x219f73
leaq 0xc1b51(%rip), %rax     # 0x2dbac4
movq %rax, 0x58907e(%rip)    # 0x7a2ff8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x219fcd
leaq 0x2ae958(%rip), %rax    # 0x4c8923
jmp 0x219ffc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x219fe1
leaq 0x1c2a1f(%rip), %rax    # 0x3dc9fe
jmp 0x219ffc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x219ff5
leaq 0x80927(%rip), %rax     # 0x29a91a
jmp 0x219ffc
leaq 0xd266c(%rip), %rax     # 0x2ec668
movq %rax, 0x588ffd(%rip)    # 0x7a3000
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21a056
leaq 0x2b0869(%rip), %rax    # 0x4ca8bd
jmp 0x21a085
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a06a
leaq 0x1c431b(%rip), %rax    # 0x3de383
jmp 0x21a085
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a07e
leaq 0x8089e(%rip), %rax     # 0x29a91a
jmp 0x21a085
leaq 0xd41c9(%rip), %rax     # 0x2ee24e
movq %rax, 0x588f7c(%rip)    # 0x7a3008
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21a0df
leaq 0x2b267d(%rip), %rax    # 0x4cc75a
jmp 0x21a10e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a0f3
leaq 0x1c5d51(%rip), %rax    # 0x3dfe42
jmp 0x21a10e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a107
leaq 0x80815(%rip), %rax     # 0x29a91a
jmp 0x21a10e
leaq 0xd5d0e(%rip), %rax     # 0x2efe1c
movq %rax, 0x588efb(%rip)    # 0x7a3010
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21a168
leaq 0x2b499c(%rip), %rax    # 0x4ceb02
jmp 0x21a197
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a17c
leaq 0x1c7b8a(%rip), %rax    # 0x3e1d04
jmp 0x21a197
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a190
leaq 0x8078c(%rip), %rax     # 0x29a91a
jmp 0x21a197
leaq 0xd7e4f(%rip), %rax     # 0x2f1fe6
movq %rax, 0x588e7a(%rip)    # 0x7a3018
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21a1f1
leaq 0x2c5cec(%rip), %rax    # 0x4dfedb
jmp 0x21a220
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a205
leaq 0x1d383a(%rip), %rax    # 0x3eda3d
jmp 0x21a220
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a219
leaq 0x7f885(%rip), %rax     # 0x299a9c
jmp 0x21a220
leaq 0xe4b81(%rip), %rax     # 0x2feda1
movq %rax, 0x588df9(%rip)    # 0x7a3020
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21a27a
leaq 0x2c7840(%rip), %rax    # 0x4e1ab8
jmp 0x21a2a9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a28e
leaq 0x1d4fd7(%rip), %rax    # 0x3ef263
jmp 0x21a2a9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a2a2
leaq 0x7f7fc(%rip), %rax     # 0x299a9c
jmp 0x21a2a9
leaq 0xe656b(%rip), %rax     # 0x300814
movq %rax, 0x588d78(%rip)    # 0x7a3028
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a303
leaq 0x2c97ae(%rip), %rax    # 0x4e3aaf
jmp 0x21a332
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a317
leaq 0x1d68ba(%rip), %rax    # 0x3f0bcf
jmp 0x21a332
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a32b
leaq 0x7f773(%rip), %rax     # 0x299a9c
jmp 0x21a332
leaq 0xe7f13(%rip), %rax     # 0x302245
movq %rax, 0x588cf7(%rip)    # 0x7a3030
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a38c
leaq 0x2cbdb9(%rip), %rax    # 0x4e6143
jmp 0x21a3bb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a3a0
leaq 0x1d8809(%rip), %rax    # 0x3f2ba7
jmp 0x21a3bb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a3b4
leaq 0x7f6ea(%rip), %rax     # 0x299a9c
jmp 0x21a3bb
leaq 0xea22b(%rip), %rax     # 0x3045e6
movq %rax, 0x588c76(%rip)    # 0x7a3038
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a415
leaq 0x2b6f31(%rip), %rax    # 0x4d1344
jmp 0x21a444
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a429
leaq 0x1c97e9(%rip), %rax    # 0x3e3c10
jmp 0x21a444
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a43d
leaq 0x7f661(%rip), %rax     # 0x299a9c
jmp 0x21a444
leaq 0xd9e9a(%rip), %rax     # 0x2f42de
movq %rax, 0x588bf5(%rip)    # 0x7a3040
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a49e
leaq 0x2b966c(%rip), %rax    # 0x4d3b08
jmp 0x21a4cd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a4b2
leaq 0x1cb4d8(%rip), %rax    # 0x3e5988
jmp 0x21a4cd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a4c6
leaq 0x7f5d8(%rip), %rax     # 0x299a9c
jmp 0x21a4cd
leaq 0xdbf18(%rip), %rax     # 0x2f63e5
movq %rax, 0x588b74(%rip)    # 0x7a3048
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a527
leaq 0x2bca67(%rip), %rax    # 0x4d6f8c
jmp 0x21a556
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a53b
leaq 0x1cd88d(%rip), %rax    # 0x3e7dc6
jmp 0x21a556
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a54f
leaq 0x7f54f(%rip), %rax     # 0x299a9c
jmp 0x21a556
leaq 0xde574(%rip), %rax     # 0x2f8aca
movq %rax, 0x588af3(%rip)    # 0x7a3050
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a5b0
leaq 0x2c1f21(%rip), %rax    # 0x4dc4cf
jmp 0x21a5df
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a5c4
leaq 0x1d0c4d(%rip), %rax    # 0x3eb20f
jmp 0x21a5df
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a5d8
leaq 0x7f4c6(%rip), %rax     # 0x299a9c
jmp 0x21a5df
leaq 0xe1d71(%rip), %rax     # 0x2fc350
movq %rax, 0x588a72(%rip)    # 0x7a3058
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a639
leaq 0x2cf794(%rip), %rax    # 0x4e9dcb
jmp 0x21a668
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a64d
leaq 0x1dbf51(%rip), %rax    # 0x3f659c
jmp 0x21a668
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a661
leaq 0x802bb(%rip), %rax     # 0x29a91a
jmp 0x21a668
leaq 0xed61f(%rip), %rax     # 0x307c87
movq %rax, 0x5889f1(%rip)    # 0x7a3060
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a6c2
leaq 0x2d3267(%rip), %rax    # 0x4ed927
jmp 0x21a6f1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a6d6
leaq 0x1df3e8(%rip), %rax    # 0x3f9abc
jmp 0x21a6f1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a6ea
leaq 0x80232(%rip), %rax     # 0x29a91a
jmp 0x21a6f1
leaq 0xf10a0(%rip), %rax     # 0x30b791
movq %rax, 0x588970(%rip)    # 0x7a3068
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x21a74b
leaq 0x2d7030(%rip), %rax    # 0x4f1779
jmp 0x21a77a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a75f
leaq 0x1e2ae1(%rip), %rax    # 0x3fd23e
jmp 0x21a77a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a773
leaq 0x801a9(%rip), %rax     # 0x29a91a
jmp 0x21a77a
leaq 0xf4bf6(%rip), %rax     # 0x30f370
movq %rax, 0x5888ef(%rip)    # 0x7a3070
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