LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc6c7
leaq 0x2b8524(%rip), %rax    # 0x474be9
jmp 0x1bc6f6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc6db
leaq 0x1c3a77(%rip), %rax    # 0x380150
jmp 0x1bc6f6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc6ef
leaq 0x811c1(%rip), %rax     # 0x23d8ae
jmp 0x1bc6f6
leaq 0xb68d3(%rip), %rax     # 0x272fc9
movq %rax, 0x57f8b3(%rip)    # 0x73bfb0
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc750
leaq 0x2bb7cf(%rip), %rax    # 0x477f1d
jmp 0x1bc77f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc764
leaq 0x1c6d9d(%rip), %rax    # 0x3834ff
jmp 0x1bc77f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc778
leaq 0x81138(%rip), %rax     # 0x23d8ae
jmp 0x1bc77f
leaq 0xba1a9(%rip), %rax     # 0x276928
movq %rax, 0x57f832(%rip)    # 0x73bfb8
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc7d9
leaq 0x2cf78b(%rip), %rax    # 0x48bf62
jmp 0x1bc808
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc7ed
leaq 0x1d8f79(%rip), %rax    # 0x395764
jmp 0x1bc808
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc801
leaq 0x80041(%rip), %rax     # 0x23c840
jmp 0x1bc808
leaq 0xcf322(%rip), %rax     # 0x28bb2a
movq %rax, 0x57f7b1(%rip)    # 0x73bfc0
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_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 0x5672cf
testl %eax, %eax
je 0x1bc862
leaq 0x2d2b1e(%rip), %rax    # 0x48f37e
jmp 0x1bc891
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc876
leaq 0x1dc3d3(%rip), %rax    # 0x398c47
jmp 0x1bc891
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc88a
leaq 0x7ffb8(%rip), %rax     # 0x23c840
jmp 0x1bc891
leaq 0xd2fdb(%rip), %rax     # 0x28f86c
movq %rax, 0x57f730(%rip)    # 0x73bfc8
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_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 0x5672cf
testl %eax, %eax
je 0x1bc8eb
leaq 0x2d5bd0(%rip), %rax    # 0x4924b9
jmp 0x1bc91a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc8ff
leaq 0x1df5d6(%rip), %rax    # 0x39bed3
jmp 0x1bc91a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc913
leaq 0x7ff2f(%rip), %rax     # 0x23c840
jmp 0x1bc91a
leaq 0xd654e(%rip), %rax     # 0x292e68
movq %rax, 0x57f6af(%rip)    # 0x73bfd0
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_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 0x5672cf
testl %eax, %eax
je 0x1bc974
leaq 0x2d8d74(%rip), %rax    # 0x4956e6
jmp 0x1bc9a3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc988
leaq 0x1e2825(%rip), %rax    # 0x39f1ab
jmp 0x1bc9a3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc99c
leaq 0x7fea6(%rip), %rax     # 0x23c840
jmp 0x1bc9a3
leaq 0xd9d07(%rip), %rax     # 0x2966aa
movq %rax, 0x57f62e(%rip)    # 0x73bfd8
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_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 0x5672cf
testl %eax, %eax
je 0x1bc9fd
leaq 0x2beec6(%rip), %rax    # 0x47b8c1
jmp 0x1bca2c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bca11
leaq 0x1ca3c5(%rip), %rax    # 0x386dd4
jmp 0x1bca2c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bca25
leaq 0x7fe1d(%rip), %rax     # 0x23c840
jmp 0x1bca2c
leaq 0xbe260(%rip), %rax     # 0x27ac8c
movq %rax, 0x57f5ad(%rip)    # 0x73bfe0
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_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 0x5672cf
testl %eax, %eax
je 0x1bca86
leaq 0x2c2586(%rip), %rax    # 0x47f00a
jmp 0x1bcab5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bca9a
leaq 0x1cd8b6(%rip), %rax    # 0x38a34e
jmp 0x1bcab5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcaae
leaq 0x7fd94(%rip), %rax     # 0x23c840
jmp 0x1bcab5
leaq 0xc1ecd(%rip), %rax     # 0x27e982
movq %rax, 0x57f52c(%rip)    # 0x73bfe8
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_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 0x5672cf
testl %eax, %eax
je 0x1bcb0f
leaq 0x2c6462(%rip), %rax    # 0x482f6f
jmp 0x1bcb3e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcb23
leaq 0x1d0f1c(%rip), %rax    # 0x38da3d
jmp 0x1bcb3e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcb37
leaq 0x7fd0b(%rip), %rax     # 0x23c840
jmp 0x1bcb3e
leaq 0xc58d0(%rip), %rax     # 0x28240e
movq %rax, 0x57f4ab(%rip)    # 0x73bff0
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_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 0x5672cf
testl %eax, %eax
je 0x1bcb98
leaq 0x2cb205(%rip), %rax    # 0x487d9b
jmp 0x1bcbc7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcbac
leaq 0x1d4e55(%rip), %rax    # 0x3919ff
jmp 0x1bcbc7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcbc0
leaq 0x7fc82(%rip), %rax     # 0x23c840
jmp 0x1bcbc7
leaq 0xca3f7(%rip), %rax     # 0x286fbe
movq %rax, 0x57f42a(%rip)    # 0x73bff8
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_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 0x5672cf
testl %eax, %eax
je 0x1bcc21
leaq 0x2dcb0c(%rip), %rax    # 0x49972b
jmp 0x1bcc50
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcc35
leaq 0x1e4c98(%rip), %rax    # 0x3a18cb
jmp 0x1bcc50
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcc49
leaq 0x80c67(%rip), %rax     # 0x23d8ae
jmp 0x1bcc50
leaq 0xddd1f(%rip), %rax     # 0x29a96f
movq %rax, 0x57f3a9(%rip)    # 0x73c000
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_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 0x5672cf
testl %eax, %eax
je 0x1bccaa
leaq 0x2dea0a(%rip), %rax    # 0x49b6b2
jmp 0x1bccd9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bccbe
leaq 0x1e68e2(%rip), %rax    # 0x3a359e
jmp 0x1bccd9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bccd2
leaq 0x80bde(%rip), %rax     # 0x23d8ae
jmp 0x1bccd9
leaq 0xdfe1f(%rip), %rax     # 0x29caf8
movq %rax, 0x57f328(%rip)    # 0x73c008
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_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 0x5672cf
testl %eax, %eax
je 0x1bcd33
leaq 0x2e0b71(%rip), %rax    # 0x49d8a2
jmp 0x1bcd62
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcd47
leaq 0x1e8718(%rip), %rax    # 0x3a545d
jmp 0x1bcd62
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcd5b
leaq 0x80b55(%rip), %rax     # 0x23d8ae
jmp 0x1bcd62
leaq 0xe1d9e(%rip), %rax     # 0x29eb00
movq %rax, 0x57f2a7(%rip)    # 0x73c010
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_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 0x5672cf
testl %eax, %eax
je 0x1bcdbc
leaq 0x2e317b(%rip), %rax    # 0x49ff35
jmp 0x1bcdeb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcdd0
leaq 0x1ea803(%rip), %rax    # 0x3a75d1
jmp 0x1bcdeb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcde4
leaq 0x80acc(%rip), %rax     # 0x23d8ae
jmp 0x1bcdeb
leaq 0xe42bd(%rip), %rax     # 0x2a10a8
movq %rax, 0x57f226(%rip)    # 0x73c018
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_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 0x5672cf
testl %eax, %eax
je 0x1bce45
leaq 0x2f48a0(%rip), %rax    # 0x4b16e3
jmp 0x1bce74
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bce59
leaq 0x1f7105(%rip), %rax    # 0x3b3f5c
jmp 0x1bce74
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bce6d
leaq 0x7f9d5(%rip), %rax     # 0x23c840
jmp 0x1bce74
leaq 0xf28c1(%rip), %rax     # 0x2af735
movq %rax, 0x57f1a5(%rip)    # 0x73c020
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_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 0x5672cf
testl %eax, %eax
je 0x1bcece
leaq 0x2f691e(%rip), %rax    # 0x4b37ea
jmp 0x1bcefd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcee2
leaq 0x1f8ffa(%rip), %rax    # 0x3b5eda
jmp 0x1bcefd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcef6
leaq 0x7f94c(%rip), %rax     # 0x23c840
jmp 0x1bcefd
leaq 0xf4b68(%rip), %rax     # 0x2b1a65
movq %rax, 0x57f124(%rip)    # 0x73c028
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_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 0x5672cf
testl %eax, %eax
je 0x1bcf57
leaq 0x2f8c3c(%rip), %rax    # 0x4b5b91
jmp 0x1bcf86
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcf6b
leaq 0x1fb004(%rip), %rax    # 0x3b7f6d
jmp 0x1bcf86
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bcf7f
leaq 0x7f8c3(%rip), %rax     # 0x23c840
jmp 0x1bcf86
leaq 0xf6c70(%rip), %rax     # 0x2b3bf6
movq %rax, 0x57f0a3(%rip)    # 0x73c030
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_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 0x5672cf
testl %eax, %eax
je 0x1bcfe0
leaq 0x2fb540(%rip), %rax    # 0x4b851e
jmp 0x1bd00f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bcff4
leaq 0x1fd2e9(%rip), %rax    # 0x3ba2db
jmp 0x1bd00f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd008
leaq 0x7f83a(%rip), %rax     # 0x23c840
jmp 0x1bd00f
leaq 0xf9146(%rip), %rax     # 0x2b6155
movq %rax, 0x57f022(%rip)    # 0x73c038
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_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 0x5672cf
testl %eax, %eax
je 0x1bd069
leaq 0x2e5622(%rip), %rax    # 0x4a2689
jmp 0x1bd098
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd07d
leaq 0x1ec6a8(%rip), %rax    # 0x3a9723
jmp 0x1bd098
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd091
leaq 0x7f7b1(%rip), %rax     # 0x23c840
jmp 0x1bd098
leaq 0xe6945(%rip), %rax     # 0x2a39dd
movq %rax, 0x57efa1(%rip)    # 0x73c040
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_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 0x5672cf
testl %eax, %eax
je 0x1bd0f2
leaq 0x2e7ded(%rip), %rax    # 0x4a4edd
jmp 0x1bd121
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd106
leaq 0x1ee54b(%rip), %rax    # 0x3ab64f
jmp 0x1bd121
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd11a
leaq 0x7f728(%rip), %rax     # 0x23c840
jmp 0x1bd121
leaq 0xe8c0a(%rip), %rax     # 0x2a5d2b
movq %rax, 0x57ef20(%rip)    # 0x73c048
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_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 0x5672cf
testl %eax, %eax
je 0x1bd17b
leaq 0x2eb54b(%rip), %rax    # 0x4a86c4
jmp 0x1bd1aa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd18f
leaq 0x1f0b04(%rip), %rax    # 0x3adc91
jmp 0x1bd1aa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd1a3
leaq 0x7f69f(%rip), %rax     # 0x23c840
jmp 0x1bd1aa
leaq 0xeb53b(%rip), %rax     # 0x2a86e5
movq %rax, 0x57ee9f(%rip)    # 0x73c050
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_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 0x5672cf
testl %eax, %eax
je 0x1bd204
leaq 0x2f0d57(%rip), %rax    # 0x4adf59
jmp 0x1bd233
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd218
leaq 0x1f4237(%rip), %rax    # 0x3b144d
jmp 0x1bd233
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd22c
leaq 0x7f616(%rip), %rax     # 0x23c840
jmp 0x1bd233
leaq 0xef2f3(%rip), %rax     # 0x2ac526
movq %rax, 0x57ee1e(%rip)    # 0x73c058
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