LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cb6a2
leaq 0x2d9892(%rip), %rax    # 0x4a4f32
jmp 0x1cb6d1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb6b6
leaq 0x1dfff0(%rip), %rax    # 0x3ab6a4
jmp 0x1cb6d1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb6ca
leaq 0x711cd(%rip), %rax     # 0x23c895
jmp 0x1cb6d1
leaq 0xda6af(%rip), %rax     # 0x2a5d80
movq %rax, 0x571690(%rip)    # 0x73cd68
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_diag_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 0x5672cf
testl %eax, %eax
je 0x1cb72b
leaq 0x2dcff0(%rip), %rax    # 0x4a8719
jmp 0x1cb75a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb73f
leaq 0x1e25a9(%rip), %rax    # 0x3adce6
jmp 0x1cb75a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb753
leaq 0x71144(%rip), %rax     # 0x23c895
jmp 0x1cb75a
leaq 0xdcfe0(%rip), %rax     # 0x2a873a
movq %rax, 0x57160f(%rip)    # 0x73cd70
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_table_diag_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 0x5672cf
testl %eax, %eax
je 0x1cb7b4
leaq 0x2e27fc(%rip), %rax    # 0x4adfae
jmp 0x1cb7e3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb7c8
leaq 0x1e5cdc(%rip), %rax    # 0x3b14a2
jmp 0x1cb7e3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb7dc
leaq 0x710bb(%rip), %rax     # 0x23c895
jmp 0x1cb7e3
leaq 0xe0d98(%rip), %rax     # 0x2ac57b
movq %rax, 0x57158e(%rip)    # 0x73cd78
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cb83d
leaq 0x2f0c0c(%rip), %rax    # 0x4bc447
jmp 0x1cb86c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb851
leaq 0x1f2caa(%rip), %rax    # 0x3be4f9
jmp 0x1cb86c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb865
leaq 0x720a0(%rip), %rax     # 0x23d903
jmp 0x1cb86c
leaq 0xeec92(%rip), %rax     # 0x2ba4fe
movq %rax, 0x57150d(%rip)    # 0x73cd80
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cb8c6
leaq 0x2f4a02(%rip), %rax    # 0x4c02c6
jmp 0x1cb8f5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb8da
leaq 0x1f6792(%rip), %rax    # 0x3c206a
jmp 0x1cb8f5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb8ee
leaq 0x72017(%rip), %rax     # 0x23d903
jmp 0x1cb8f5
leaq 0xf310c(%rip), %rax     # 0x2bea01
movq %rax, 0x57148c(%rip)    # 0x73cd88
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cb94f
leaq 0x2f8771(%rip), %rax    # 0x4c40be
jmp 0x1cb97e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb963
leaq 0x1fa1c0(%rip), %rax    # 0x3c5b21
jmp 0x1cb97e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cb977
leaq 0x71f8e(%rip), %rax     # 0x23d903
jmp 0x1cb97e
leaq 0xf6ffc(%rip), %rax     # 0x2c297a
movq %rax, 0x57140b(%rip)    # 0x73cd90
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cb9d8
leaq 0x2fca77(%rip), %rax    # 0x4c844d
jmp 0x1cba07
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cb9ec
leaq 0x1fdeee(%rip), %rax    # 0x3c98d8
jmp 0x1cba07
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cba00
leaq 0x71f05(%rip), %rax     # 0x23d903
jmp 0x1cba07
leaq 0xfb21b(%rip), %rax     # 0x2c6c22
movq %rax, 0x57138a(%rip)    # 0x73cd98
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cba61
leaq 0x315d66(%rip), %rax    # 0x4e17c5
jmp 0x1cba90
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cba75
leaq 0x213397(%rip), %rax    # 0x3dee0a
jmp 0x1cba90
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cba89
leaq 0x70e0e(%rip), %rax     # 0x23c895
jmp 0x1cba90
leaq 0x1134da(%rip), %rax    # 0x2def6a
movq %rax, 0x571309(%rip)    # 0x73cda0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cbaea
leaq 0x319c45(%rip), %rax    # 0x4e572d
jmp 0x1cbb19
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbafe
leaq 0x217012(%rip), %rax    # 0x3e2b0e
jmp 0x1cbb19
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbb12
leaq 0x70d85(%rip), %rax     # 0x23c895
jmp 0x1cbb19
leaq 0x117a0b(%rip), %rax    # 0x2e3524
movq %rax, 0x571288(%rip)    # 0x73cda8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cbb73
leaq 0x31dcf4(%rip), %rax    # 0x4e9865
jmp 0x1cbba2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbb87
leaq 0x21adf1(%rip), %rax    # 0x3e6976
jmp 0x1cbba2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbb9b
leaq 0x70cfc(%rip), %rax     # 0x23c895
jmp 0x1cbba2
leaq 0x11bb4d(%rip), %rax    # 0x2e76ef
movq %rax, 0x571207(%rip)    # 0x73cdb0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cbbfc
leaq 0x322404(%rip), %rax    # 0x4edffe
jmp 0x1cbc2b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbc10
leaq 0x21ef1b(%rip), %rax    # 0x3eab29
jmp 0x1cbc2b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbc24
leaq 0x70c73(%rip), %rax     # 0x23c895
jmp 0x1cbc2b
leaq 0x12009f(%rip), %rax    # 0x2ebcca
movq %rax, 0x571186(%rip)    # 0x73cdb8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cbc85
leaq 0x300b70(%rip), %rax    # 0x4cc7f3
jmp 0x1cbcb4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbc99
leaq 0x201c95(%rip), %rax    # 0x3cd92c
jmp 0x1cbcb4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbcad
leaq 0x70bea(%rip), %rax     # 0x23c895
jmp 0x1cbcb4
leaq 0xff953(%rip), %rax     # 0x2cb607
movq %rax, 0x571105(%rip)    # 0x73cdc0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cbd0e
leaq 0x304b9a(%rip), %rax    # 0x4d08a6
jmp 0x1cbd3d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbd22
leaq 0x205782(%rip), %rax    # 0x3d14a2
jmp 0x1cbd3d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbd36
leaq 0x70b61(%rip), %rax     # 0x23c895
jmp 0x1cbd3d
leaq 0x103c74(%rip), %rax    # 0x2cf9b1
movq %rax, 0x571084(%rip)    # 0x73cdc8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cbd97
leaq 0x309ba4(%rip), %rax    # 0x4d5939
jmp 0x1cbdc6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbdab
leaq 0x209815(%rip), %rax    # 0x3d55be
jmp 0x1cbdc6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbdbf
leaq 0x70ad8(%rip), %rax     # 0x23c895
jmp 0x1cbdc6
leaq 0x108175(%rip), %rax    # 0x2d3f3b
movq %rax, 0x571003(%rip)    # 0x73cdd0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_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 0x5672cf
testl %eax, %eax
je 0x1cbe20
leaq 0x31079d(%rip), %rax    # 0x4dc5bb
jmp 0x1cbe4f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbe34
leaq 0x20e93a(%rip), %rax    # 0x3da76c
jmp 0x1cbe4f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbe48
leaq 0x70a4f(%rip), %rax     # 0x23c895
jmp 0x1cbe4f
leaq 0x10dd81(%rip), %rax    # 0x2d9bd0
movq %rax, 0x570f82(%rip)    # 0x73cdd8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cbea9
leaq 0x32534e(%rip), %rax    # 0x4f11f5
jmp 0x1cbed8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbebd
leaq 0x2218f7(%rip), %rax    # 0x3ed7b2
jmp 0x1cbed8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbed1
leaq 0x71a34(%rip), %rax     # 0x23d903
jmp 0x1cbed8
leaq 0x123181(%rip), %rax    # 0x2ef059
movq %rax, 0x570f01(%rip)    # 0x73cde0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cbf32
leaq 0x3271da(%rip), %rax    # 0x4f310a
jmp 0x1cbf61
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbf46
leaq 0x2235bb(%rip), %rax    # 0x3ef4ff
jmp 0x1cbf61
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbf5a
leaq 0x719ab(%rip), %rax     # 0x23d903
jmp 0x1cbf61
leaq 0x125314(%rip), %rax    # 0x2f1275
movq %rax, 0x570e80(%rip)    # 0x73cde8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cbfbb
leaq 0x329279(%rip), %rax    # 0x4f5232
jmp 0x1cbfea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cbfcf
leaq 0x2253bb(%rip), %rax    # 0x3f1388
jmp 0x1cbfea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cbfe3
leaq 0x71922(%rip), %rax     # 0x23d903
jmp 0x1cbfea
leaq 0x127288(%rip), %rax    # 0x2f3272
movq %rax, 0x570dff(%rip)    # 0x73cdf0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cc044
leaq 0x32b845(%rip), %rax    # 0x4f7887
jmp 0x1cc073
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cc058
leaq 0x227401(%rip), %rax    # 0x3f3457
jmp 0x1cc073
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cc06c
leaq 0x71899(%rip), %rax     # 0x23d903
jmp 0x1cc073
leaq 0x12959a(%rip), %rax    # 0x2f560d
movq %rax, 0x570d7e(%rip)    # 0x73cdf8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cc0cd
leaq 0x33d778(%rip), %rax    # 0x509843
jmp 0x1cc0fc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cc0e1
leaq 0x233e8f(%rip), %rax    # 0x3fff6e
jmp 0x1cc0fc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cc0f5
leaq 0x707a2(%rip), %rax     # 0x23c895
jmp 0x1cc0fc
leaq 0x137d98(%rip), %rax    # 0x303e94
movq %rax, 0x570cfd(%rip)    # 0x73ce00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cc156
leaq 0x33f3f2(%rip), %rax    # 0x50b546
jmp 0x1cc185
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cc16a
leaq 0x2359ed(%rip), %rax    # 0x401b55
jmp 0x1cc185
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cc17e
leaq 0x70719(%rip), %rax     # 0x23c895
jmp 0x1cc185
leaq 0x139d5f(%rip), %rax    # 0x305ee4
movq %rax, 0x570c7c(%rip)    # 0x73ce08
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_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 0x5672cf
testl %eax, %eax
je 0x1cc1df
leaq 0x3411fe(%rip), %rax    # 0x50d3db
jmp 0x1cc20e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cc1f3
leaq 0x23757b(%rip), %rax    # 0x40376c
jmp 0x1cc20e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cc207
leaq 0x70690(%rip), %rax     # 0x23c895
jmp 0x1cc20e
leaq 0x13ba2b(%rip), %rax    # 0x307c39
movq %rax, 0x570bfb(%rip)    # 0x73ce10
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