LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_diag_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_diag_8_pointer = parasail_sg_db_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_diag_8_pointer = parasail_sg_db_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_diag_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1caadc
leaq 0x298c52(%rip), %rax    # 0x46372c
jmp 0x1cab0b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1caaf0
leaq 0x1a430b(%rip), %rax    # 0x36edf9
jmp 0x1cab0b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cab04
leaq 0x71d93(%rip), %rax     # 0x23c895
jmp 0x1cab0b
leaq 0x9515d(%rip), %rax     # 0x25fc68
movq %rax, 0x5721a6(%rip)    # 0x73ccb8
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_db_dispatch.c
// Function: parasail_sg_db_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_db_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1cab65
leaq 0x2a3601(%rip), %rax    # 0x46e164
jmp 0x1cab94
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cab79
leaq 0x1aec38(%rip), %rax    # 0x3797af
jmp 0x1cab94
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cab8d
leaq 0x72d78(%rip), %rax     # 0x23d903
jmp 0x1cab94
leaq 0xa0cd8(%rip), %rax     # 0x26b86c
movq %rax, 0x572125(%rip)    # 0x73ccc0
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_db_dispatch.c
// Function: parasail_sg_db_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_db_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_scan_32_pointer = parasail_sg_db_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_32_pointer = parasail_sg_db_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_32_pointer = parasail_sg_db_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_32_pointer = parasail_sg_db_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_32_pointer = parasail_sg_db_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_scan_32_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1cabee
leaq 0x2a6d21(%rip), %rax    # 0x47190d
jmp 0x1cac1d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cac02
leaq 0x1b225a(%rip), %rax    # 0x37ce5a
jmp 0x1cac1d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cac16
leaq 0x72cef(%rip), %rax     # 0x23d903
jmp 0x1cac1d
leaq 0xa4c30(%rip), %rax     # 0x26f84d
movq %rax, 0x5720a4(%rip)    # 0x73ccc8
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_db_dispatch.c
// Function: parasail_sg_db_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_scan_16_pointer = parasail_sg_db_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_16_pointer = parasail_sg_db_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_16_pointer = parasail_sg_db_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_16_pointer = parasail_sg_db_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_16_pointer = parasail_sg_db_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_scan_16_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1cac77
leaq 0x2a9fc9(%rip), %rax    # 0x474c3e
jmp 0x1caca6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cac8b
leaq 0x1b551c(%rip), %rax    # 0x3801a5
jmp 0x1caca6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cac9f
leaq 0x72c66(%rip), %rax     # 0x23d903
jmp 0x1caca6
leaq 0xa8378(%rip), %rax     # 0x27301e
movq %rax, 0x572023(%rip)    # 0x73ccd0
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_db_dispatch.c
// Function: parasail_sg_db_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_scan_8_pointer = parasail_sg_db_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_scan_8_pointer = parasail_sg_db_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_scan_8_pointer = parasail_sg_db_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_scan_8_pointer = parasail_sg_db_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_scan_8_pointer = parasail_sg_db_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_scan_8_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1cad00
leaq 0x2ad274(%rip), %rax    # 0x477f72
jmp 0x1cad2f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cad14
leaq 0x1b8842(%rip), %rax    # 0x383554
jmp 0x1cad2f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cad28
leaq 0x72bdd(%rip), %rax     # 0x23d903
jmp 0x1cad2f
leaq 0xabc4e(%rip), %rax     # 0x27697d
movq %rax, 0x571fa2(%rip)    # 0x73ccd8
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_db_dispatch.c
// Function: parasail_sg_db_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_striped_64_pointer = parasail_sg_db_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_64_pointer = parasail_sg_db_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_64_pointer = parasail_sg_db_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_64_pointer = parasail_sg_db_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_64_pointer = parasail_sg_db_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_striped_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cad89
leaq 0x2c1230(%rip), %rax    # 0x48bfb7
jmp 0x1cadb8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cad9d
leaq 0x1caa1e(%rip), %rax    # 0x3957b9
jmp 0x1cadb8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cadb1
leaq 0x71ae6(%rip), %rax     # 0x23c895
jmp 0x1cadb8
leaq 0xc0dc7(%rip), %rax     # 0x28bb7f
movq %rax, 0x571f21(%rip)    # 0x73cce0
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_db_dispatch.c
// Function: parasail_sg_db_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cae12
leaq 0x2c45c3(%rip), %rax    # 0x48f3d3
jmp 0x1cae41
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cae26
leaq 0x1cde78(%rip), %rax    # 0x398c9c
jmp 0x1cae41
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cae3a
leaq 0x71a5d(%rip), %rax     # 0x23c895
jmp 0x1cae41
leaq 0xc4a80(%rip), %rax     # 0x28f8c1
movq %rax, 0x571ea0(%rip)    # 0x73cce8
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_db_dispatch.c
// Function: parasail_sg_db_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cae9b
leaq 0x2c7675(%rip), %rax    # 0x49250e
jmp 0x1caeca
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1caeaf
leaq 0x1d107b(%rip), %rax    # 0x39bf28
jmp 0x1caeca
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1caec3
leaq 0x719d4(%rip), %rax     # 0x23c895
jmp 0x1caeca
leaq 0xc7ff3(%rip), %rax     # 0x292ebd
movq %rax, 0x571e1f(%rip)    # 0x73ccf0
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_db_dispatch.c
// Function: parasail_sg_db_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1caf24
leaq 0x2ca819(%rip), %rax    # 0x49573b
jmp 0x1caf53
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1caf38
leaq 0x1d42ca(%rip), %rax    # 0x39f200
jmp 0x1caf53
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1caf4c
leaq 0x7194b(%rip), %rax     # 0x23c895
jmp 0x1caf53
leaq 0xcb7ac(%rip), %rax     # 0x2966ff
movq %rax, 0x571d9e(%rip)    # 0x73ccf8
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cafad
leaq 0x2b096b(%rip), %rax    # 0x47b916
jmp 0x1cafdc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cafc1
leaq 0x1bbe6a(%rip), %rax    # 0x386e29
jmp 0x1cafdc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cafd5
leaq 0x718c2(%rip), %rax     # 0x23c895
jmp 0x1cafdc
leaq 0xafd05(%rip), %rax     # 0x27ace1
movq %rax, 0x571d1d(%rip)    # 0x73cd00
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb036
leaq 0x2b402b(%rip), %rax    # 0x47f05f
jmp 0x1cb065
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb04a
leaq 0x1bf35b(%rip), %rax    # 0x38a3a3
jmp 0x1cb065
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb05e
leaq 0x71839(%rip), %rax     # 0x23c895
jmp 0x1cb065
leaq 0xb3972(%rip), %rax     # 0x27e9d7
movq %rax, 0x571c9c(%rip)    # 0x73cd08
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb0bf
leaq 0x2b7f07(%rip), %rax    # 0x482fc4
jmp 0x1cb0ee
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb0d3
leaq 0x1c29c1(%rip), %rax    # 0x38da92
jmp 0x1cb0ee
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb0e7
leaq 0x717b0(%rip), %rax     # 0x23c895
jmp 0x1cb0ee
leaq 0xb7375(%rip), %rax     # 0x282463
movq %rax, 0x571c1b(%rip)    # 0x73cd10
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb148
leaq 0x2bccaa(%rip), %rax    # 0x487df0
jmp 0x1cb177
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb15c
leaq 0x1c68fa(%rip), %rax    # 0x391a54
jmp 0x1cb177
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb170
leaq 0x71727(%rip), %rax     # 0x23c895
jmp 0x1cb177
leaq 0xbbe9c(%rip), %rax     # 0x287013
movq %rax, 0x571b9a(%rip)    # 0x73cd18
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_64_pointer = parasail_sg_db_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1cb1d1
leaq 0x2ce5b1(%rip), %rax    # 0x499780
jmp 0x1cb200
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb1e5
leaq 0x1d673d(%rip), %rax    # 0x3a1920
jmp 0x1cb200
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb1f9
leaq 0x7270c(%rip), %rax     # 0x23d903
jmp 0x1cb200
leaq 0xcf7c4(%rip), %rax     # 0x29a9c4
movq %rax, 0x571b19(%rip)    # 0x73cd20
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_32_pointer = parasail_sg_db_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1cb25a
leaq 0x2d04af(%rip), %rax    # 0x49b707
jmp 0x1cb289
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb26e
leaq 0x1d8387(%rip), %rax    # 0x3a35f3
jmp 0x1cb289
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb282
leaq 0x72683(%rip), %rax     # 0x23d903
jmp 0x1cb289
leaq 0xd18c4(%rip), %rax     # 0x29cb4d
movq %rax, 0x571a98(%rip)    # 0x73cd28
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_16_pointer = parasail_sg_db_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1cb2e3
leaq 0x2d2616(%rip), %rax    # 0x49d8f7
jmp 0x1cb312
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb2f7
leaq 0x1da1bd(%rip), %rax    # 0x3a54b2
jmp 0x1cb312
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb30b
leaq 0x725fa(%rip), %rax     # 0x23d903
jmp 0x1cb312
leaq 0xd3843(%rip), %rax     # 0x29eb55
movq %rax, 0x571a17(%rip)    # 0x73cd30
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_8_pointer = parasail_sg_db_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1cb36c
leaq 0x2d4c20(%rip), %rax    # 0x49ff8a
jmp 0x1cb39b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb380
leaq 0x1dc2a8(%rip), %rax    # 0x3a7626
jmp 0x1cb39b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb394
leaq 0x72571(%rip), %rax     # 0x23d903
jmp 0x1cb39b
leaq 0xd5d62(%rip), %rax     # 0x2a10fd
movq %rax, 0x571996(%rip)    # 0x73cd38
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_64_pointer = parasail_sg_db_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb3f5
leaq 0x2e6345(%rip), %rax    # 0x4b1738
jmp 0x1cb424
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb409
leaq 0x1e8baa(%rip), %rax    # 0x3b3fb1
jmp 0x1cb424
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb41d
leaq 0x7147a(%rip), %rax     # 0x23c895
jmp 0x1cb424
leaq 0xe4366(%rip), %rax     # 0x2af78a
movq %rax, 0x571915(%rip)    # 0x73cd40
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_32_pointer = parasail_sg_db_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb47e
leaq 0x2e83c3(%rip), %rax    # 0x4b383f
jmp 0x1cb4ad
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb492
leaq 0x1eaa9f(%rip), %rax    # 0x3b5f2f
jmp 0x1cb4ad
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb4a6
leaq 0x713f1(%rip), %rax     # 0x23c895
jmp 0x1cb4ad
leaq 0xe660d(%rip), %rax     # 0x2b1aba
movq %rax, 0x571894(%rip)    # 0x73cd48
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_16_pointer = parasail_sg_db_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb507
leaq 0x2ea6e1(%rip), %rax    # 0x4b5be6
jmp 0x1cb536
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb51b
leaq 0x1ecaa9(%rip), %rax    # 0x3b7fc2
jmp 0x1cb536
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb52f
leaq 0x71368(%rip), %rax     # 0x23c895
jmp 0x1cb536
leaq 0xe8715(%rip), %rax     # 0x2b3c4b
movq %rax, 0x571813(%rip)    # 0x73cd50
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_8_pointer = parasail_sg_db_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb590
leaq 0x2ecfe5(%rip), %rax    # 0x4b8573
jmp 0x1cb5bf
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb5a4
leaq 0x1eed8e(%rip), %rax    # 0x3ba330
jmp 0x1cb5bf
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb5b8
leaq 0x712df(%rip), %rax     # 0x23c895
jmp 0x1cb5bf
leaq 0xeabeb(%rip), %rax     # 0x2b61aa
movq %rax, 0x571792(%rip)    # 0x73cd58
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_db_dispatch.c
// Function: parasail_sg_db_table_diag_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_diag_64_pointer = parasail_sg_db_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1cb619
leaq 0x2d70c7(%rip), %rax    # 0x4a26de
jmp 0x1cb648
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb62d
leaq 0x1de14d(%rip), %rax    # 0x3a9778
jmp 0x1cb648
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb641
leaq 0x71256(%rip), %rax     # 0x23c895
jmp 0x1cb648
leaq 0xd83ea(%rip), %rax     # 0x2a3a32
movq %rax, 0x571711(%rip)    # 0x73cd60
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