LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x227f9a
leaq 0x279d86(%rip), %rax    # 0x4a1d1e
jmp 0x227fc9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x227fae
leaq 0x192b6e(%rip), %rax    # 0x3bab1a
jmp 0x227fc9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x227fc2
leaq 0x729b2(%rip), %rax     # 0x29a972
jmp 0x227fc9
leaq 0x9dadc(%rip), %rax     # 0x2c5aa5
movq %rax, 0x57bcf8(%rip)    # 0x7a3cc8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x228023
leaq 0x27cb99(%rip), %rax    # 0x4a4bba
jmp 0x228052
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228037
leaq 0x195920(%rip), %rax    # 0x3bd955
jmp 0x228052
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22804b
leaq 0x72929(%rip), %rax     # 0x29a972
jmp 0x228052
leaq 0xa0d28(%rip), %rax     # 0x2c8d7a
movq %rax, 0x57bc77(%rip)    # 0x7a3cd0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2280ac
leaq 0x27f9d2(%rip), %rax    # 0x4a7a7c
jmp 0x2280db
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2280c0
leaq 0x198775(%rip), %rax    # 0x3c0833
jmp 0x2280db
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2280d4
leaq 0x728a0(%rip), %rax     # 0x29a972
jmp 0x2280db
leaq 0xa4138(%rip), %rax     # 0x2cc213
movq %rax, 0x57bbf6(%rip)    # 0x7a3cd8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x228135
leaq 0x2943d4(%rip), %rax    # 0x4bc507
jmp 0x228164
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228149
leaq 0x1a9e5c(%rip), %rax    # 0x3d1fa3
jmp 0x228164
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22815d
leaq 0x71999(%rip), %rax     # 0x299af4
jmp 0x228164
leaq 0xb791e(%rip), %rax     # 0x2dfa82
movq %rax, 0x57bb75(%rip)    # 0x7a3ce0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2281be
leaq 0x297359(%rip), %rax    # 0x4bf515
jmp 0x2281ed
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2281d2
leaq 0x1acbe1(%rip), %rax    # 0x3d4db1
jmp 0x2281ed
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2281e6
leaq 0x71910(%rip), %rax     # 0x299af4
jmp 0x2281ed
leaq 0xbad05(%rip), %rax     # 0x2e2ef2
movq %rax, 0x57baf4(%rip)    # 0x7a3ce8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x228247
leaq 0x299e80(%rip), %rax    # 0x4c20c5
jmp 0x228276
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22825b
leaq 0x1af774(%rip), %rax    # 0x3d79cd
jmp 0x228276
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22826f
leaq 0x71887(%rip), %rax     # 0x299af4
jmp 0x228276
leaq 0xbdc4c(%rip), %rax     # 0x2e5ec2
movq %rax, 0x57ba73(%rip)    # 0x7a3cf0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2282d0
leaq 0x29ca40(%rip), %rax    # 0x4c4d0e
jmp 0x2282ff
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2282e4
leaq 0x1b23ab(%rip), %rax    # 0x3da68d
jmp 0x2282ff
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2282f8
leaq 0x717fe(%rip), %rax     # 0x299af4
jmp 0x2282ff
leaq 0xc0de0(%rip), %rax     # 0x2e90df
movq %rax, 0x57b9f2(%rip)    # 0x7a3cf8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x228359
leaq 0x28312a(%rip), %rax    # 0x4ab481
jmp 0x228388
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22836d
leaq 0x19b91e(%rip), %rax    # 0x3c3c89
jmp 0x228388
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228381
leaq 0x71775(%rip), %rax     # 0x299af4
jmp 0x228388
leaq 0xa7a7b(%rip), %rax     # 0x2cfe03
movq %rax, 0x57b971(%rip)    # 0x7a3d00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2283e2
leaq 0x286ab5(%rip), %rax    # 0x4aee95
jmp 0x228411
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2283f6
leaq 0x19eb6a(%rip), %rax    # 0x3c6f5e
jmp 0x228411
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22840a
leaq 0x716ec(%rip), %rax     # 0x299af4
jmp 0x228411
leaq 0xab3c3(%rip), %rax     # 0x2d37d4
movq %rax, 0x57b8f0(%rip)    # 0x7a3d08
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22846b
leaq 0x28a965(%rip), %rax    # 0x4b2dce
jmp 0x22849a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22847f
leaq 0x1a221e(%rip), %rax    # 0x3ca69b
jmp 0x22849a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228493
leaq 0x71663(%rip), %rax     # 0x299af4
jmp 0x22849a
leaq 0xaee1e(%rip), %rax     # 0x2d72b8
movq %rax, 0x57b86f(%rip)    # 0x7a3d10
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2284f4
leaq 0x28fc68(%rip), %rax    # 0x4b815a
jmp 0x228523
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228508
leaq 0x1a62ae(%rip), %rax    # 0x3ce7b4
jmp 0x228523
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22851c
leaq 0x715da(%rip), %rax     # 0x299af4
jmp 0x228523
leaq 0xb35f9(%rip), %rax     # 0x2dbb1c
movq %rax, 0x57b7ee(%rip)    # 0x7a3d18
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22857d
leaq 0x2a0400(%rip), %rax    # 0x4c897b
jmp 0x2285ac
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228591
leaq 0x1b44c7(%rip), %rax    # 0x3dca56
jmp 0x2285ac
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2285a5
leaq 0x723cf(%rip), %rax     # 0x29a972
jmp 0x2285ac
leaq 0xc4114(%rip), %rax     # 0x2ec6c0
movq %rax, 0x57b76d(%rip)    # 0x7a3d20
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x228606
leaq 0x2a2311(%rip), %rax    # 0x4ca915
jmp 0x228635
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22861a
leaq 0x1b5dc3(%rip), %rax    # 0x3de3db
jmp 0x228635
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22862e
leaq 0x72346(%rip), %rax     # 0x29a972
jmp 0x228635
leaq 0xc5c71(%rip), %rax     # 0x2ee2a6
movq %rax, 0x57b6ec(%rip)    # 0x7a3d28
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22868f
leaq 0x2a4125(%rip), %rax    # 0x4cc7b2
jmp 0x2286be
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2286a3
leaq 0x1b77f9(%rip), %rax    # 0x3dfe9a
jmp 0x2286be
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2286b7
leaq 0x722bd(%rip), %rax     # 0x29a972
jmp 0x2286be
leaq 0xc77b6(%rip), %rax     # 0x2efe74
movq %rax, 0x57b66b(%rip)    # 0x7a3d30
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x228718
leaq 0x2a6444(%rip), %rax    # 0x4ceb5a
jmp 0x228747
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22872c
leaq 0x1b9632(%rip), %rax    # 0x3e1d5c
jmp 0x228747
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228740
leaq 0x72234(%rip), %rax     # 0x29a972
jmp 0x228747
leaq 0xc98f7(%rip), %rax     # 0x2f203e
movq %rax, 0x57b5ea(%rip)    # 0x7a3d38
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2287a1
leaq 0x2b7794(%rip), %rax    # 0x4dff33
jmp 0x2287d0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2287b5
leaq 0x1c52e2(%rip), %rax    # 0x3eda95
jmp 0x2287d0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2287c9
leaq 0x7132d(%rip), %rax     # 0x299af4
jmp 0x2287d0
leaq 0xd6629(%rip), %rax     # 0x2fedf9
movq %rax, 0x57b569(%rip)    # 0x7a3d40
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22882a
leaq 0x2b92e8(%rip), %rax    # 0x4e1b10
jmp 0x228859
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22883e
leaq 0x1c6a7f(%rip), %rax    # 0x3ef2bb
jmp 0x228859
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228852
leaq 0x712a4(%rip), %rax     # 0x299af4
jmp 0x228859
leaq 0xd8013(%rip), %rax     # 0x30086c
movq %rax, 0x57b4e8(%rip)    # 0x7a3d48
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2288b3
leaq 0x2bb256(%rip), %rax    # 0x4e3b07
jmp 0x2288e2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2288c7
leaq 0x1c8362(%rip), %rax    # 0x3f0c27
jmp 0x2288e2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2288db
leaq 0x7121b(%rip), %rax     # 0x299af4
jmp 0x2288e2
leaq 0xd99bb(%rip), %rax     # 0x30229d
movq %rax, 0x57b467(%rip)    # 0x7a3d50
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22893c
leaq 0x2bd861(%rip), %rax    # 0x4e619b
jmp 0x22896b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228950
leaq 0x1ca2b1(%rip), %rax    # 0x3f2bff
jmp 0x22896b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228964
leaq 0x71192(%rip), %rax     # 0x299af4
jmp 0x22896b
leaq 0xdbcd3(%rip), %rax     # 0x30463e
movq %rax, 0x57b3e6(%rip)    # 0x7a3d58
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2289c5
leaq 0x2a89d9(%rip), %rax    # 0x4d139c
jmp 0x2289f4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2289d9
leaq 0x1bb291(%rip), %rax    # 0x3e3c68
jmp 0x2289f4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2289ed
leaq 0x71109(%rip), %rax     # 0x299af4
jmp 0x2289f4
leaq 0xcb942(%rip), %rax     # 0x2f4336
movq %rax, 0x57b365(%rip)    # 0x7a3d60
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_diag_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_diag_32_pointer = parasail_sg_db_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228a4e
leaq 0x2ab114(%rip), %rax    # 0x4d3b60
jmp 0x228a7d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228a62
leaq 0x1bcf80(%rip), %rax    # 0x3e59e0
jmp 0x228a7d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228a76
leaq 0x71080(%rip), %rax     # 0x299af4
jmp 0x228a7d
leaq 0xcd9c0(%rip), %rax     # 0x2f643d
movq %rax, 0x57b2e4(%rip)    # 0x7a3d68
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_diag_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_diag_16_pointer = parasail_sg_db_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228ad7
leaq 0x2ae50f(%rip), %rax    # 0x4d6fe4
jmp 0x228b06
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228aeb
leaq 0x1bf335(%rip), %rax    # 0x3e7e1e
jmp 0x228b06
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228aff
leaq 0x70ff7(%rip), %rax     # 0x299af4
jmp 0x228b06
leaq 0xd001c(%rip), %rax     # 0x2f8b22
movq %rax, 0x57b263(%rip)    # 0x7a3d70
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