LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x217ade
leaq 0x344008(%rip), %rax    # 0x55bae4
jmp 0x217b0d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217af2
leaq 0x23b8d8(%rip), %rax    # 0x4533c8
jmp 0x217b0d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217b06
leaq 0x836bc(%rip), %rax     # 0x29b1c0
jmp 0x217b0d
leaq 0x1428c7(%rip), %rax    # 0x35a3d4
movq %rax, 0x5c1194(%rip)    # 0x7d8ca8
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/sw_dispatch.c
// Function: parasail_sw_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x217b67
leaq 0x3476a7(%rip), %rax    # 0x55f20c
jmp 0x217b96
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217b7b
leaq 0x23dc97(%rip), %rax    # 0x455810
jmp 0x217b96
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217b8f
leaq 0x83633(%rip), %rax     # 0x29b1c0
jmp 0x217b96
leaq 0x144f22(%rip), %rax    # 0x35cab8
movq %rax, 0x5c1113(%rip)    # 0x7d8cb0
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/sw_dispatch.c
// Function: parasail_sw_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x217bf0
leaq 0x34cc56(%rip), %rax    # 0x564844
jmp 0x217c1f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217c04
leaq 0x2412c6(%rip), %rax    # 0x458ec8
jmp 0x217c1f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217c18
leaq 0x835aa(%rip), %rax     # 0x29b1c0
jmp 0x217c1f
leaq 0x148b29(%rip), %rax    # 0x360748
movq %rax, 0x5c1092(%rip)    # 0x7d8cb8
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x217c79
leaq 0x35a6d1(%rip), %rax    # 0x572348
jmp 0x217ca8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217c8d
leaq 0x24c725(%rip), %rax    # 0x4643b0
jmp 0x217ca8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217ca1
leaq 0x8481d(%rip), %rax     # 0x29c4bc
jmp 0x217ca8
leaq 0x155bc4(%rip), %rax    # 0x36d86c
movq %rax, 0x5c1011(%rip)    # 0x7d8cc0
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x217d02
leaq 0x35ded8(%rip), %rax    # 0x575bd8
jmp 0x217d31
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217d16
leaq 0x24fc5c(%rip), %rax    # 0x467970
jmp 0x217d31
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217d2a
leaq 0x84794(%rip), %rax     # 0x29c4bc
jmp 0x217d31
leaq 0x159a37(%rip), %rax    # 0x371768
movq %rax, 0x5c0f90(%rip)    # 0x7d8cc8
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x217d8b
leaq 0x36284b(%rip), %rax    # 0x57a5d4
jmp 0x217dba
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217d9f
leaq 0x25397f(%rip), %rax    # 0x46b71c
jmp 0x217dba
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217db3
leaq 0x8470b(%rip), %rax     # 0x29c4bc
jmp 0x217dba
leaq 0x15df36(%rip), %rax    # 0x375cf0
movq %rax, 0x5c0f0f(%rip)    # 0x7d8cd0
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x217e14
leaq 0x367c32(%rip), %rax    # 0x57fa44
jmp 0x217e43
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217e28
leaq 0x2583a2(%rip), %rax    # 0x4701c8
jmp 0x217e43
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217e3c
leaq 0x84682(%rip), %rax     # 0x29c4bc
jmp 0x217e43
leaq 0x163549(%rip), %rax    # 0x37b38c
movq %rax, 0x5c0e8e(%rip)    # 0x7d8cd8
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x217e9d
leaq 0x380905(%rip), %rax    # 0x5987a0
jmp 0x217ecc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217eb1
leaq 0x26d2d1(%rip), %rax    # 0x485180
jmp 0x217ecc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217ec5
leaq 0x832fd(%rip), %rax     # 0x29b1c0
jmp 0x217ecc
leaq 0x17b194(%rip), %rax    # 0x393060
movq %rax, 0x5c0e0d(%rip)    # 0x7d8ce0
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x217f26
leaq 0x383cc4(%rip), %rax    # 0x59bbe8
jmp 0x217f55
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217f3a
leaq 0x27051c(%rip), %rax    # 0x488454
jmp 0x217f55
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217f4e
leaq 0x83274(%rip), %rax     # 0x29b1c0
jmp 0x217f55
leaq 0x17eebb(%rip), %rax    # 0x396e10
movq %rax, 0x5c0d8c(%rip)    # 0x7d8ce8
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x217faf
leaq 0x38841f(%rip), %rax    # 0x5a03cc
jmp 0x217fde
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x217fc3
leaq 0x273e0f(%rip), %rax    # 0x48bdd0
jmp 0x217fde
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x217fd7
leaq 0x831eb(%rip), %rax     # 0x29b1c0
jmp 0x217fde
leaq 0x182e46(%rip), %rax    # 0x39ae24
movq %rax, 0x5c0d0b(%rip)    # 0x7d8cf0
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x218038
leaq 0x38dba2(%rip), %rax    # 0x5a5bd8
jmp 0x218067
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21804c
leaq 0x27851a(%rip), %rax    # 0x490564
jmp 0x218067
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x218060
leaq 0x83162(%rip), %rax     # 0x29b1c0
jmp 0x218067
leaq 0x187edd(%rip), %rax    # 0x39ff44
movq %rax, 0x5c0c8a(%rip)    # 0x7d8cf8
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x2180c1
leaq 0x36b9ad(%rip), %rax    # 0x583a6c
jmp 0x2180f0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2180d5
leaq 0x25bd7d(%rip), %rax    # 0x473e50
jmp 0x2180f0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2180e9
leaq 0x830d9(%rip), %rax     # 0x29b1c0
jmp 0x2180f0
leaq 0x167904(%rip), %rax    # 0x37f9f4
movq %rax, 0x5c0c09(%rip)    # 0x7d8d00
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x21814a
leaq 0x36fa14(%rip), %rax    # 0x587b5c
jmp 0x218179
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21815e
leaq 0x25f8d4(%rip), %rax    # 0x477a30
jmp 0x218179
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x218172
leaq 0x83050(%rip), %rax     # 0x29b1c0
jmp 0x218179
leaq 0x16bd1b(%rip), %rax    # 0x383e94
movq %rax, 0x5c0b88(%rip)    # 0x7d8d08
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x2181d3
leaq 0x374bcb(%rip), %rax    # 0x58cd9c
jmp 0x218202
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2181e7
leaq 0x263b37(%rip), %rax    # 0x47bd1c
jmp 0x218202
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2181fb
leaq 0x82fc7(%rip), %rax     # 0x29b1c0
jmp 0x218202
leaq 0x170282(%rip), %rax    # 0x388484
movq %rax, 0x5c0b07(%rip)    # 0x7d8d10
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/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x21825c
leaq 0x37bad6(%rip), %rax    # 0x593d30
jmp 0x21828b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x218270
leaq 0x268f52(%rip), %rax    # 0x4811c0
jmp 0x21828b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x218284
leaq 0x82f3e(%rip), %rax     # 0x29b1c0
jmp 0x21828b
leaq 0x175f6d(%rip), %rax    # 0x38e1f8
movq %rax, 0x5c0a86(%rip)    # 0x7d8d18
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/sw_dispatch.c
// Function: parasail_sw_trace_scan_64_dispatcher
parasail_result_t* parasail_sw_trace_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_sw_trace_scan_64_pointer = parasail_sw_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x2182e5
leaq 0x390135(%rip), %rax    # 0x5a8418
jmp 0x218314
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2182f9
leaq 0x27ad65(%rip), %rax    # 0x49305c
jmp 0x218314
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21830d
leaq 0x841b1(%rip), %rax     # 0x29c4bc
jmp 0x218314
leaq 0x18ae74(%rip), %rax    # 0x3a3188
movq %rax, 0x5c0a05(%rip)    # 0x7d8d20
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/sw_dispatch.c
// Function: parasail_sw_trace_scan_32_dispatcher
parasail_result_t* parasail_sw_trace_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_sw_trace_scan_32_pointer = parasail_sw_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x21836e
leaq 0x391d78(%rip), %rax    # 0x5aa0e4
jmp 0x21839d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x218382
leaq 0x27c970(%rip), %rax    # 0x494cf0
jmp 0x21839d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x218396
leaq 0x84128(%rip), %rax     # 0x29c4bc
jmp 0x21839d
leaq 0x18d00b(%rip), %rax    # 0x3a53a8
movq %rax, 0x5c0984(%rip)    # 0x7d8d28
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/sw_dispatch.c
// Function: parasail_sw_trace_scan_16_dispatcher
parasail_result_t* parasail_sw_trace_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_sw_trace_scan_16_pointer = parasail_sw_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x2183f7
leaq 0x3943df(%rip), %rax    # 0x5ac7d4
jmp 0x218426
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21840b
leaq 0x27e807(%rip), %rax    # 0x496c10
jmp 0x218426
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21841f
leaq 0x8409f(%rip), %rax     # 0x29c4bc
jmp 0x218426
leaq 0x18f34a(%rip), %rax    # 0x3a7770
movq %rax, 0x5c0903(%rip)    # 0x7d8d30
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/sw_dispatch.c
// Function: parasail_sw_trace_scan_8_dispatcher
parasail_result_t* parasail_sw_trace_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_sw_trace_scan_8_pointer = parasail_sw_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_trace_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x218480
leaq 0x3977fa(%rip), %rax    # 0x5afc78
jmp 0x2184af
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x218494
leaq 0x280aaa(%rip), %rax    # 0x498f3c
jmp 0x2184af
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2184a8
leaq 0x84016(%rip), %rax     # 0x29c4bc
jmp 0x2184af
leaq 0x191ea5(%rip), %rax    # 0x3aa354
movq %rax, 0x5c0882(%rip)    # 0x7d8d38
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/sw_dispatch.c
// Function: parasail_sw_trace_striped_64_dispatcher
parasail_result_t* parasail_sw_trace_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_sw_trace_striped_64_pointer = parasail_sw_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x218509
leaq 0x3a7811(%rip), %rax    # 0x5bfd18
jmp 0x218538
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21851d
leaq 0x28c96d(%rip), %rax    # 0x4a4e88
jmp 0x218538
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x218531
leaq 0x82c91(%rip), %rax     # 0x29b1c0
jmp 0x218538
leaq 0x19fcc0(%rip), %rax    # 0x3b81f8
movq %rax, 0x5c0801(%rip)    # 0x7d8d40
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/sw_dispatch.c
// Function: parasail_sw_trace_striped_32_dispatcher
parasail_result_t* parasail_sw_trace_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_sw_trace_striped_32_pointer = parasail_sw_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x218592
leaq 0x3a98f8(%rip), %rax    # 0x5c1e88
jmp 0x2185c1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2185a6
leaq 0x28eb08(%rip), %rax    # 0x4a70ac
jmp 0x2185c1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2185ba
leaq 0x82c08(%rip), %rax     # 0x29b1c0
jmp 0x2185c1
leaq 0x1a259f(%rip), %rax    # 0x3bab60
movq %rax, 0x5c0780(%rip)    # 0x7d8d48
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/sw_dispatch.c
// Function: parasail_sw_trace_striped_16_dispatcher
parasail_result_t* parasail_sw_trace_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_sw_trace_striped_16_pointer = parasail_sw_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x21861b
leaq 0x3ac4c7(%rip), %rax    # 0x5c4ae0
jmp 0x21864a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21862f
leaq 0x290f5f(%rip), %rax    # 0x4a958c
jmp 0x21864a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x218643
leaq 0x82b7f(%rip), %rax     # 0x29b1c0
jmp 0x21864a
leaq 0x1a4eba(%rip), %rax    # 0x3bd504
movq %rax, 0x5c06ff(%rip)    # 0x7d8d50
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