LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_diag_16_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20dbdb
leaq 0x32101f(%rip), %rax    # 0x52ebf8
jmp 0x20dc0a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20dbef
leaq 0x220647(%rip), %rax    # 0x42e234
jmp 0x20dc0a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20dc03
leaq 0x8cbdb(%rip), %rax     # 0x29a7dc
jmp 0x20dc0a
leaq 0x121a82(%rip), %rax    # 0x32f68c
movq %rax, 0x5ca77f(%rip)    # 0x7d8390
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_diag_8_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20dc64
leaq 0x326726(%rip), %rax    # 0x534388
jmp 0x20dc93
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20dc78
leaq 0x22490e(%rip), %rax    # 0x432584
jmp 0x20dc93
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20dc8c
leaq 0x8cb52(%rip), %rax     # 0x29a7dc
jmp 0x20dc93
leaq 0x125ff9(%rip), %rax    # 0x333c8c
movq %rax, 0x5ca6fe(%rip)    # 0x7d8398
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_scan_64_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20dced
leaq 0x340225(%rip), %rax    # 0x54df10
jmp 0x20dd1c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20dd01
leaq 0x23ab59(%rip), %rax    # 0x448858
jmp 0x20dd1c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20dd15
leaq 0x8d851(%rip), %rax     # 0x29b564
jmp 0x20dd1c
leaq 0x13f78c(%rip), %rax    # 0x34d4a8
movq %rax, 0x5ca67d(%rip)    # 0x7d83a0
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_scan_32_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20dd76
leaq 0x341cac(%rip), %rax    # 0x54fa20
jmp 0x20dda5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20dd8a
leaq 0x23c594(%rip), %rax    # 0x44a31c
jmp 0x20dda5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20dd9e
leaq 0x8d7c8(%rip), %rax     # 0x29b564
jmp 0x20dda5
leaq 0x1418f7(%rip), %rax    # 0x34f69c
movq %rax, 0x5ca5fc(%rip)    # 0x7d83a8
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_scan_16_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20ddff
leaq 0x3437a7(%rip), %rax    # 0x5515a4
jmp 0x20de2e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20de13
leaq 0x23e037(%rip), %rax    # 0x44be48
jmp 0x20de2e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20de27
leaq 0x8d73f(%rip), %rax     # 0x29b564
jmp 0x20de2e
leaq 0x143852(%rip), %rax    # 0x351680
movq %rax, 0x5ca57b(%rip)    # 0x7d83b0
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_scan_8_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20de88
leaq 0x346206(%rip), %rax    # 0x55408c
jmp 0x20deb7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20de9c
leaq 0x23ff06(%rip), %rax    # 0x44dda0
jmp 0x20deb7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20deb0
leaq 0x8d6b6(%rip), %rax     # 0x29b564
jmp 0x20deb7
leaq 0x145add(%rip), %rax    # 0x353994
movq %rax, 0x5ca4fa(%rip)    # 0x7d83b8
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_64_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20df11
leaq 0x358779(%rip), %rax    # 0x566688
jmp 0x20df40
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20df25
leaq 0x24c3ed(%rip), %rax    # 0x45a310
jmp 0x20df40
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20df39
leaq 0x8c8a5(%rip), %rax     # 0x29a7dc
jmp 0x20df40
leaq 0x153e04(%rip), %rax    # 0x361d44
movq %rax, 0x5ca479(%rip)    # 0x7d83c0
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_32_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20df9a
leaq 0x359f08(%rip), %rax    # 0x567ea0
jmp 0x20dfc9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20dfae
leaq 0x24dc40(%rip), %rax    # 0x45bbec
jmp 0x20dfc9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20dfc2
leaq 0x8c81c(%rip), %rax     # 0x29a7dc
jmp 0x20dfc9
leaq 0x155e5f(%rip), %rax    # 0x363e28
movq %rax, 0x5ca3f8(%rip)    # 0x7d83c8
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_16_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20e023
leaq 0x35b743(%rip), %rax    # 0x569764
jmp 0x20e052
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e037
leaq 0x24f407(%rip), %rax    # 0x45d43c
jmp 0x20e052
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e04b
leaq 0x8c793(%rip), %rax     # 0x29a7dc
jmp 0x20e052
leaq 0x157aa2(%rip), %rax    # 0x365af4
movq %rax, 0x5ca377(%rip)    # 0x7d83d0
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_8_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20e0ac
leaq 0x35df36(%rip), %rax    # 0x56bfe0
jmp 0x20e0db
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e0c0
leaq 0x251096(%rip), %rax    # 0x45f154
jmp 0x20e0db
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e0d4
leaq 0x8c70a(%rip), %rax     # 0x29a7dc
jmp 0x20e0db
leaq 0x159a4d(%rip), %rax    # 0x367b28
movq %rax, 0x5ca2f6(%rip)    # 0x7d83d8
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_64_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20e135
leaq 0x349ec1(%rip), %rax    # 0x557ff4
jmp 0x20e164
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e149
leaq 0x242381(%rip), %rax    # 0x4504c8
jmp 0x20e164
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e15d
leaq 0x8c681(%rip), %rax     # 0x29a7dc
jmp 0x20e164
leaq 0x14896c(%rip), %rax    # 0x356ad0
movq %rax, 0x5ca275(%rip)    # 0x7d83e0
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_32_dispatcher
parasail_result_t* parasail_nw_rowcol_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_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_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 0x5c8fdb
testl %eax, %eax
je 0x20e1be
leaq 0x34bd9c(%rip), %rax    # 0x559f58
jmp 0x20e1ed
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e1d2
leaq 0x243d30(%rip), %rax    # 0x451f00
jmp 0x20e1ed
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e1e6
leaq 0x8c5f8(%rip), %rax     # 0x29a7dc
jmp 0x20e1ed
leaq 0x14aaeb(%rip), %rax    # 0x358cd8
movq %rax, 0x5ca1f4(%rip)    # 0x7d83e8
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_16_dispatcher
parasail_result_t* parasail_nw_rowcol_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_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_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 0x5c8fdb
testl %eax, %eax
je 0x20e247
leaq 0x34e433(%rip), %rax    # 0x55c678
jmp 0x20e276
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e25b
leaq 0x2459ef(%rip), %rax    # 0x453c48
jmp 0x20e276
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e26f
leaq 0x8c56f(%rip), %rax     # 0x29a7dc
jmp 0x20e276
leaq 0x14cac6(%rip), %rax    # 0x35ad3c
movq %rax, 0x5ca173(%rip)    # 0x7d83f0
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_8_dispatcher
parasail_result_t* parasail_nw_rowcol_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_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_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 0x5c8fdb
testl %eax, %eax
je 0x20e2d0
leaq 0x3521b2(%rip), %rax    # 0x560480
jmp 0x20e2ff
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e2e4
leaq 0x2480aa(%rip), %rax    # 0x45638c
jmp 0x20e2ff
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e2f8
leaq 0x8c4e6(%rip), %rax     # 0x29a7dc
jmp 0x20e2ff
leaq 0x14f3f1(%rip), %rax    # 0x35d6f0
movq %rax, 0x5ca0f2(%rip)    # 0x7d83f8
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e359
leaq 0x36198d(%rip), %rax    # 0x56fce4
jmp 0x20e388
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e36d
leaq 0x253a81(%rip), %rax    # 0x461dec
jmp 0x20e388
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e381
leaq 0x8d1e5(%rip), %rax     # 0x29b564
jmp 0x20e388
leaq 0x15c4fc(%rip), %rax    # 0x36a884
movq %rax, 0x5ca071(%rip)    # 0x7d8400
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e3e2
leaq 0x364fcc(%rip), %rax    # 0x5733ac
jmp 0x20e411
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e3f6
leaq 0x256fa4(%rip), %rax    # 0x465398
jmp 0x20e411
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e40a
leaq 0x8d15c(%rip), %rax     # 0x29b564
jmp 0x20e411
leaq 0x160943(%rip), %rax    # 0x36ed54
movq %rax, 0x5c9ff0(%rip)    # 0x7d8408
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e46b
leaq 0x36885f(%rip), %rax    # 0x576cc8
jmp 0x20e49a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e47f
leaq 0x25a50b(%rip), %rax    # 0x468988
jmp 0x20e49a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e493
leaq 0x8d0d3(%rip), %rax     # 0x29b564
jmp 0x20e49a
leaq 0x164546(%rip), %rax    # 0x3729e0
movq %rax, 0x5c9f6f(%rip)    # 0x7d8410
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e4f4
leaq 0x36d542(%rip), %rax    # 0x57ba34
jmp 0x20e523
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e508
leaq 0x25e41e(%rip), %rax    # 0x46c924
jmp 0x20e523
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e51c
leaq 0x8d04a(%rip), %rax     # 0x29b564
jmp 0x20e523
leaq 0x168b29(%rip), %rax    # 0x37704c
movq %rax, 0x5c9eee(%rip)    # 0x7d8418
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e57d
leaq 0x387f29(%rip), %rax    # 0x5964a4
jmp 0x20e5ac
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e591
leaq 0x2749cd(%rip), %rax    # 0x482f5c
jmp 0x20e5ac
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e5a5
leaq 0x8c239(%rip), %rax     # 0x29a7dc
jmp 0x20e5ac
leaq 0x181d00(%rip), %rax    # 0x3902ac
movq %rax, 0x5c9e6d(%rip)    # 0x7d8420
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e606
leaq 0x38b214(%rip), %rax    # 0x599818
jmp 0x20e635
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e61a
leaq 0x277bb4(%rip), %rax    # 0x4861cc
jmp 0x20e635
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e62e
leaq 0x8c1b0(%rip), %rax     # 0x29a7dc
jmp 0x20e635
leaq 0x185f5f(%rip), %rax    # 0x394594
movq %rax, 0x5c9dec(%rip)    # 0x7d8428
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e68f
leaq 0x38e643(%rip), %rax    # 0x59ccd0
jmp 0x20e6be
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e6a3
leaq 0x27addb(%rip), %rax    # 0x48947c
jmp 0x20e6be
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e6b7
leaq 0x8c127(%rip), %rax     # 0x29a7dc
jmp 0x20e6be
leaq 0x1899ee(%rip), %rax    # 0x3980ac
movq %rax, 0x5c9d6b(%rip)    # 0x7d8430
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_nw_stats_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_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20e718
leaq 0x39328e(%rip), %rax    # 0x5a19a4
jmp 0x20e747
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20e72c
leaq 0x27e996(%rip), %rax    # 0x48d0c0
jmp 0x20e747
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20e740
leaq 0x8c09e(%rip), %rax     # 0x29a7dc
jmp 0x20e747
leaq 0x18db1d(%rip), %rax    # 0x39c264
movq %rax, 0x5c9cea(%rip)    # 0x7d8438
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