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_table_diag_8_dispatcher
parasail_result_t* parasail_sg_db_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228b60
leaq 0x2b39c9(%rip), %rax    # 0x4dc527
jmp 0x228b8f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228b74
leaq 0x1c26f5(%rip), %rax    # 0x3eb267
jmp 0x228b8f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228b88
leaq 0x70f6e(%rip), %rax     # 0x299af4
jmp 0x228b8f
leaq 0xd3819(%rip), %rax     # 0x2fc3a8
movq %rax, 0x57b1e2(%rip)    # 0x7a3d78
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_table_scan_64_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228be9
leaq 0x2c123c(%rip), %rax    # 0x4e9e23
jmp 0x228c18
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228bfd
leaq 0x1cd9f9(%rip), %rax    # 0x3f65f4
jmp 0x228c18
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228c11
leaq 0x71d63(%rip), %rax     # 0x29a972
jmp 0x228c18
leaq 0xdf0c7(%rip), %rax     # 0x307cdf
movq %rax, 0x57b161(%rip)    # 0x7a3d80
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_table_scan_32_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_32_pointer = parasail_sg_db_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_32_pointer = parasail_sg_db_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_32_pointer = parasail_sg_db_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_32_pointer = parasail_sg_db_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_32_pointer = parasail_sg_db_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_scan_32_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228c72
leaq 0x2c4d0f(%rip), %rax    # 0x4ed97f
jmp 0x228ca1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228c86
leaq 0x1d0e90(%rip), %rax    # 0x3f9b14
jmp 0x228ca1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228c9a
leaq 0x71cda(%rip), %rax     # 0x29a972
jmp 0x228ca1
leaq 0xe2b48(%rip), %rax     # 0x30b7e9
movq %rax, 0x57b0e0(%rip)    # 0x7a3d88
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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_16_pointer = parasail_sg_db_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_16_pointer = parasail_sg_db_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_16_pointer = parasail_sg_db_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_16_pointer = parasail_sg_db_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_16_pointer = parasail_sg_db_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_scan_16_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228cfb
leaq 0x2c8ad8(%rip), %rax    # 0x4f17d1
jmp 0x228d2a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228d0f
leaq 0x1d4589(%rip), %rax    # 0x3fd296
jmp 0x228d2a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228d23
leaq 0x71c51(%rip), %rax     # 0x29a972
jmp 0x228d2a
leaq 0xe669e(%rip), %rax     # 0x30f3c8
movq %rax, 0x57b05f(%rip)    # 0x7a3d90
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_table_scan_8_dispatcher
parasail_result_t* parasail_sg_db_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_scan_8_pointer = parasail_sg_db_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_8_pointer = parasail_sg_db_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_8_pointer = parasail_sg_db_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_8_pointer = parasail_sg_db_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_8_pointer = parasail_sg_db_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_scan_8_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_stats_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228d84
leaq 0x2ccd27(%rip), %rax    # 0x4f5aa9
jmp 0x228db3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228d98
leaq 0x1d84e9(%rip), %rax    # 0x40127f
jmp 0x228db3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228dac
leaq 0x71bc8(%rip), %rax     # 0x29a972
jmp 0x228db3
leaq 0xeab5b(%rip), %rax     # 0x31390e
movq %rax, 0x57afde(%rip)    # 0x7a3d98
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_table_striped_64_dispatcher
parasail_result_t* parasail_sg_db_stats_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_striped_64_pointer = parasail_sg_db_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_64_pointer = parasail_sg_db_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_64_pointer = parasail_sg_db_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_64_pointer = parasail_sg_db_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_64_pointer = parasail_sg_db_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_striped_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x228e0d
leaq 0x2e782e(%rip), %rax    # 0x510639
jmp 0x228e3c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228e21
leaq 0x1ed38c(%rip), %rax    # 0x4161ab
jmp 0x228e3c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228e35
leaq 0x70cc1(%rip), %rax     # 0x299af4
jmp 0x228e3c
leaq 0x101723(%rip), %rax    # 0x32a55f
movq %rax, 0x57af5d(%rip)    # 0x7a3da0
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_table_striped_32_dispatcher
parasail_result_t* parasail_sg_db_stats_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_stats_table_striped_32_pointer = parasail_sg_db_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_32_pointer = parasail_sg_db_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_32_pointer = parasail_sg_db_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_32_pointer = parasail_sg_db_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_32_pointer = parasail_sg_db_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_striped_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_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 0x228e96
leaq 0x2eb0d8(%rip), %rax    # 0x513f6c
jmp 0x228ec5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228eaa
leaq 0x1f062f(%rip), %rax    # 0x4194d7
jmp 0x228ec5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228ebe
leaq 0x70c38(%rip), %rax     # 0x299af4
jmp 0x228ec5
leaq 0x105085(%rip), %rax    # 0x32df4a
movq %rax, 0x57aedc(%rip)    # 0x7a3da8
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_table_striped_16_dispatcher
parasail_result_t* parasail_sg_db_stats_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_stats_table_striped_16_pointer = parasail_sg_db_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_16_pointer = parasail_sg_db_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_16_pointer = parasail_sg_db_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_16_pointer = parasail_sg_db_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_16_pointer = parasail_sg_db_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_striped_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_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 0x228f1f
leaq 0x2ef786(%rip), %rax    # 0x5186a3
jmp 0x228f4e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228f33
leaq 0x1f3f95(%rip), %rax    # 0x41cec6
jmp 0x228f4e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228f47
leaq 0x70baf(%rip), %rax     # 0x299af4
jmp 0x228f4e
leaq 0x108d11(%rip), %rax    # 0x331c5f
movq %rax, 0x57ae5b(%rip)    # 0x7a3db0
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_table_striped_8_dispatcher
parasail_result_t* parasail_sg_db_stats_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_stats_table_striped_8_pointer = parasail_sg_db_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_striped_8_pointer = parasail_sg_db_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_striped_8_pointer = parasail_sg_db_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_striped_8_pointer = parasail_sg_db_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_striped_8_pointer = parasail_sg_db_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_striped_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_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 0x228fa8
leaq 0x2f41f7(%rip), %rax    # 0x51d19d
jmp 0x228fd7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x228fbc
leaq 0x1f8c80(%rip), %rax    # 0x421c3a
jmp 0x228fd7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x228fd0
leaq 0x70b26(%rip), %rax     # 0x299af4
jmp 0x228fd7
leaq 0x10ddc7(%rip), %rax    # 0x336d9e
movq %rax, 0x57adda(%rip)    # 0x7a3db8
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_table_diag_64_dispatcher
parasail_result_t* parasail_sg_db_stats_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_stats_table_diag_64_pointer = parasail_sg_db_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_diag_64_pointer = parasail_sg_db_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_diag_64_pointer = parasail_sg_db_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_diag_64_pointer = parasail_sg_db_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_diag_64_pointer = parasail_sg_db_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_diag_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_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 0x229031
leaq 0x2d10ff(%rip), %rax    # 0x4fa12e
jmp 0x229060
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x229045
leaq 0x1dbff2(%rip), %rax    # 0x405035
jmp 0x229060
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x229059
leaq 0x70a9d(%rip), %rax     # 0x299af4
jmp 0x229060
leaq 0xeed4b(%rip), %rax     # 0x317dab
movq %rax, 0x57ad59(%rip)    # 0x7a3dc0
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_table_diag_32_dispatcher
parasail_result_t* parasail_sg_db_stats_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_stats_table_diag_32_pointer = parasail_sg_db_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_diag_32_pointer = parasail_sg_db_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_diag_32_pointer = parasail_sg_db_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_diag_32_pointer = parasail_sg_db_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_diag_32_pointer = parasail_sg_db_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_diag_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_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 0x2290ba
leaq 0x2d5b5e(%rip), %rax    # 0x4fec16
jmp 0x2290e9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2290ce
leaq 0x1dfab3(%rip), %rax    # 0x408b7f
jmp 0x2290e9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2290e2
leaq 0x70a14(%rip), %rax     # 0x299af4
jmp 0x2290e9
leaq 0xf2e3f(%rip), %rax     # 0x31bf28
movq %rax, 0x57acd8(%rip)    # 0x7a3dc8
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_table_diag_16_dispatcher
parasail_result_t* parasail_sg_db_stats_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_stats_table_diag_16_pointer = parasail_sg_db_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_diag_16_pointer = parasail_sg_db_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_diag_16_pointer = parasail_sg_db_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_diag_16_pointer = parasail_sg_db_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_diag_16_pointer = parasail_sg_db_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_diag_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_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 0x229143
leaq 0x2daedc(%rip), %rax    # 0x50401d
jmp 0x229172
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x229157
leaq 0x1e3c61(%rip), %rax    # 0x40cdb6
jmp 0x229172
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22916b
leaq 0x7098b(%rip), %rax     # 0x299af4
jmp 0x229172
leaq 0xf72f0(%rip), %rax     # 0x320462
movq %rax, 0x57ac57(%rip)    # 0x7a3dd0
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_table_diag_8_dispatcher
parasail_result_t* parasail_sg_db_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_table_diag_8_pointer = parasail_sg_db_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_diag_8_pointer = parasail_sg_db_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_diag_8_pointer = parasail_sg_db_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_diag_8_pointer = parasail_sg_db_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_diag_8_pointer = parasail_sg_db_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_diag_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2291cc
leaq 0x2e2072(%rip), %rax    # 0x50b23c
jmp 0x2291fb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2291e0
leaq 0x1e8de5(%rip), %rax    # 0x411fc3
jmp 0x2291fb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2291f4
leaq 0x70902(%rip), %rax     # 0x299af4
jmp 0x2291fb
leaq 0xfcb36(%rip), %rax     # 0x325d31
movq %rax, 0x57abd6(%rip)    # 0x7a3dd8
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_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_scan_64_pointer = parasail_sg_db_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_64_pointer = parasail_sg_db_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_64_pointer = parasail_sg_db_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_64_pointer = parasail_sg_db_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_64_pointer = parasail_sg_db_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_rowcol_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 0x229255
leaq 0x2f72dd(%rip), %rax    # 0x520530
jmp 0x229284
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x229269
leaq 0x1fba82(%rip), %rax    # 0x424ce9
jmp 0x229284
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22927d
leaq 0x716f7(%rip), %rax     # 0x29a972
jmp 0x229284
leaq 0x110fcd(%rip), %rax    # 0x33a251
movq %rax, 0x57ab55(%rip)    # 0x7a3de0
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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_scan_32_pointer = parasail_sg_db_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_32_pointer = parasail_sg_db_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_32_pointer = parasail_sg_db_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_32_pointer = parasail_sg_db_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_32_pointer = parasail_sg_db_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_scan_32_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_rowcol_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 0x2292de
leaq 0x2f90ed(%rip), %rax    # 0x5223c9
jmp 0x22930d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2292f2
leaq 0x1fd428(%rip), %rax    # 0x426718
jmp 0x22930d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x229306
leaq 0x7166e(%rip), %rax     # 0x29a972
jmp 0x22930d
leaq 0x112be9(%rip), %rax    # 0x33bef6
movq %rax, 0x57aad4(%rip)    # 0x7a3de8
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_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_scan_16_pointer = parasail_sg_db_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_16_pointer = parasail_sg_db_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_16_pointer = parasail_sg_db_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_16_pointer = parasail_sg_db_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_16_pointer = parasail_sg_db_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_scan_16_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_rowcol_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 0x229367
leaq 0x2fad3a(%rip), %rax    # 0x52409f
jmp 0x229396
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22937b
leaq 0x1fed68(%rip), %rax    # 0x4280e1
jmp 0x229396
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22938f
leaq 0x715e5(%rip), %rax     # 0x29a972
jmp 0x229396
leaq 0x114649(%rip), %rax    # 0x33d9df
movq %rax, 0x57aa53(%rip)    # 0x7a3df0
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_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_scan_8_pointer = parasail_sg_db_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_scan_8_pointer = parasail_sg_db_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_scan_8_pointer = parasail_sg_db_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_scan_8_pointer = parasail_sg_db_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_scan_8_pointer = parasail_sg_db_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_scan_8_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_rowcol_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 0x2293f0
leaq 0x2fcf71(%rip), %rax    # 0x52635f
jmp 0x22941f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x229404
leaq 0x200985(%rip), %rax    # 0x429d87
jmp 0x22941f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x229418
leaq 0x7155c(%rip), %rax     # 0x29a972
jmp 0x22941f
leaq 0x1164b7(%rip), %rax    # 0x33f8d6
movq %rax, 0x57a9d2(%rip)    # 0x7a3df8
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_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_striped_64_pointer = parasail_sg_db_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_striped_64_pointer = parasail_sg_db_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_striped_64_pointer = parasail_sg_db_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_striped_64_pointer = parasail_sg_db_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_striped_64_pointer = parasail_sg_db_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_striped_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_rowcol_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 0x229479
leaq 0x30f429(%rip), %rax    # 0x5388a0
jmp 0x2294a8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22948d
leaq 0x20cdb8(%rip), %rax    # 0x436243
jmp 0x2294a8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2294a1
leaq 0x70655(%rip), %rax     # 0x299af4
jmp 0x2294a8
leaq 0x123748(%rip), %rax    # 0x34cbf0
movq %rax, 0x57a951(%rip)    # 0x7a3e00
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_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_striped_32_pointer = parasail_sg_db_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_striped_32_pointer = parasail_sg_db_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_striped_32_pointer = parasail_sg_db_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_striped_32_pointer = parasail_sg_db_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_striped_32_pointer = parasail_sg_db_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_striped_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_rowcol_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 0x229502
leaq 0x310ea5(%rip), %rax    # 0x53a3a5
jmp 0x229531
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x229516
leaq 0x20e5e3(%rip), %rax    # 0x437af7
jmp 0x229531
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22952a
leaq 0x705cc(%rip), %rax     # 0x299af4
jmp 0x229531
leaq 0x1250d8(%rip), %rax    # 0x34e609
movq %rax, 0x57a8d0(%rip)    # 0x7a3e08
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_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_striped_16_pointer = parasail_sg_db_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_striped_16_pointer = parasail_sg_db_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_striped_16_pointer = parasail_sg_db_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_striped_16_pointer = parasail_sg_db_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_striped_16_pointer = parasail_sg_db_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_striped_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_rowcol_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 0x22958b
leaq 0x3128b9(%rip), %rax    # 0x53be42
jmp 0x2295ba
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22959f
leaq 0x20fd3f(%rip), %rax    # 0x4392dc
jmp 0x2295ba
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2295b3
leaq 0x70543(%rip), %rax     # 0x299af4
jmp 0x2295ba
leaq 0x1268fa(%rip), %rax    # 0x34feb4
movq %rax, 0x57a84f(%rip)    # 0x7a3e10
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_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_striped_8_pointer = parasail_sg_db_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_striped_8_pointer = parasail_sg_db_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_striped_8_pointer = parasail_sg_db_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_striped_8_pointer = parasail_sg_db_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_striped_8_pointer = parasail_sg_db_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_striped_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_rowcol_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 0x229614
leaq 0x314910(%rip), %rax    # 0x53df22
jmp 0x229643
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x229628
leaq 0x211795(%rip), %rax    # 0x43adbb
jmp 0x229643
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22963c
leaq 0x704ba(%rip), %rax     # 0x299af4
jmp 0x229643
leaq 0x128589(%rip), %rax    # 0x351bcc
movq %rax, 0x57a7ce(%rip)    # 0x7a3e18
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_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_db_rowcol_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_rowcol_diag_64_pointer = parasail_sg_db_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_rowcol_diag_64_pointer = parasail_sg_db_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_rowcol_diag_64_pointer = parasail_sg_db_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_rowcol_diag_64_pointer = parasail_sg_db_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_rowcol_diag_64_pointer = parasail_sg_db_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_rowcol_diag_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_rowcol_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 0x22969d
leaq 0x2ff5aa(%rip), %rax    # 0x528c45
jmp 0x2296cc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2296b1
leaq 0x20268c(%rip), %rax    # 0x42bd3b
jmp 0x2296cc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2296c5
leaq 0x70431(%rip), %rax     # 0x299af4
jmp 0x2296cc
leaq 0x1184e2(%rip), %rax    # 0x341bae
movq %rax, 0x57a74d(%rip)    # 0x7a3e20
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