LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x20cbc6
leaq 0x31cdc4(%rip), %rax    # 0x529988
jmp 0x20cbf5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20cbda
leaq 0x21fb3c(%rip), %rax    # 0x42c714
jmp 0x20cbf5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20cbee
leaq 0x8c5f8(%rip), %rax     # 0x2991e4
jmp 0x20cbf5
leaq 0x135aa3(%rip), %rax    # 0x342698
movq %rax, 0x5957ec(%rip)    # 0x7a23e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20cc4f
leaq 0x31f57f(%rip), %rax    # 0x52c1cc
jmp 0x20cc7e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20cc63
leaq 0x221857(%rip), %rax    # 0x42e4b8
jmp 0x20cc7e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20cc77
leaq 0x8c56f(%rip), %rax     # 0x2991e4
jmp 0x20cc7e
leaq 0x137b0a(%rip), %rax    # 0x344788
movq %rax, 0x59576b(%rip)    # 0x7a23f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20ccd8
leaq 0x3234d6(%rip), %rax    # 0x5301ac
jmp 0x20cd07
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ccec
leaq 0x224082(%rip), %rax    # 0x430d6c
jmp 0x20cd07
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20cd00
leaq 0x8c4e6(%rip), %rax     # 0x2991e4
jmp 0x20cd07
leaq 0x13a515(%rip), %rax    # 0x34721c
movq %rax, 0x5956ea(%rip)    # 0x7a23f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20cd61
leaq 0x331e41(%rip), %rax    # 0x53eba0
jmp 0x20cd90
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20cd75
leaq 0x22f30d(%rip), %rax    # 0x43c080
jmp 0x20cd90
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20cd89
leaq 0x8d1dd(%rip), %rax     # 0x299f64
jmp 0x20cd90
leaq 0x145904(%rip), %rax    # 0x352694
movq %rax, 0x595669(%rip)    # 0x7a2400
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20cdea
leaq 0x3365d4(%rip), %rax    # 0x5433bc
jmp 0x20ce19
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20cdfe
leaq 0x232d70(%rip), %rax    # 0x43fb6c
jmp 0x20ce19
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20ce12
leaq 0x8d154(%rip), %rax     # 0x299f64
jmp 0x20ce19
leaq 0x149a4f(%rip), %rax    # 0x356868
movq %rax, 0x5955e8(%rip)    # 0x7a2408
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20ce73
leaq 0x339c5f(%rip), %rax    # 0x546ad0
jmp 0x20cea2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ce87
leaq 0x2360e7(%rip), %rax    # 0x442f6c
jmp 0x20cea2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20ce9b
leaq 0x8d0cb(%rip), %rax     # 0x299f64
jmp 0x20cea2
leaq 0x14d4de(%rip), %rax    # 0x35a380
movq %rax, 0x595567(%rip)    # 0x7a2410
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20cefc
leaq 0x33e0b2(%rip), %rax    # 0x54afac
jmp 0x20cf2b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20cf10
leaq 0x239a7a(%rip), %rax    # 0x446988
jmp 0x20cf2b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20cf24
leaq 0x8d042(%rip), %rax     # 0x299f64
jmp 0x20cf2b
leaq 0x1511b5(%rip), %rax    # 0x35e0e0
movq %rax, 0x5954e6(%rip)    # 0x7a2418
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20cf85
leaq 0x3589cd(%rip), %rax    # 0x565950
jmp 0x20cfb4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20cf99
leaq 0x24faa5(%rip), %rax    # 0x45ca3c
jmp 0x20cfb4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20cfad
leaq 0x8c239(%rip), %rax     # 0x2991e4
jmp 0x20cfb4
leaq 0x168db4(%rip), %rax    # 0x375d68
movq %rax, 0x595465(%rip)    # 0x7a2420
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20d00e
leaq 0x35ca3c(%rip), %rax    # 0x569a48
jmp 0x20d03d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d022
leaq 0x2532d4(%rip), %rax    # 0x4602f4
jmp 0x20d03d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d036
leaq 0x8c1b0(%rip), %rax     # 0x2991e4
jmp 0x20d03d
leaq 0x16cbf7(%rip), %rax    # 0x379c34
movq %rax, 0x5953e4(%rip)    # 0x7a2428
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20d097
leaq 0x35fd27(%rip), %rax    # 0x56cdbc
jmp 0x20d0c6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d0ab
leaq 0x25623b(%rip), %rax    # 0x4632e4
jmp 0x20d0c6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d0bf
leaq 0x8c127(%rip), %rax     # 0x2991e4
jmp 0x20d0c6
leaq 0x1702b6(%rip), %rax    # 0x37d37c
movq %rax, 0x595363(%rip)    # 0x7a2430
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/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 0x594f9c
testl %eax, %eax
je 0x20d120
leaq 0x363e32(%rip), %rax    # 0x570f50
jmp 0x20d14f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d134
leaq 0x25998a(%rip), %rax    # 0x466abc
jmp 0x20d14f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d148
leaq 0x8c09e(%rip), %rax     # 0x2991e4
jmp 0x20d14f
leaq 0x173c79(%rip), %rax    # 0x380dc8
movq %rax, 0x5952e2(%rip)    # 0x7a2438
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d1a9
leaq 0x341d71(%rip), %rax    # 0x54ef18
jmp 0x20d1d8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d1bd
leaq 0x23dc19(%rip), %rax    # 0x44add4
jmp 0x20d1d8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d1d1
leaq 0x8c015(%rip), %rax     # 0x2991e4
jmp 0x20d1d8
leaq 0x1559c8(%rip), %rax    # 0x362ba0
movq %rax, 0x595261(%rip)    # 0x7a2440
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d232
leaq 0x34674c(%rip), %rax    # 0x55397c
jmp 0x20d261
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d246
leaq 0x24160c(%rip), %rax    # 0x44e850
jmp 0x20d261
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d25a
leaq 0x8bf8c(%rip), %rax     # 0x2991e4
jmp 0x20d261
leaq 0x159ad3(%rip), %rax    # 0x366d34
movq %rax, 0x5951e0(%rip)    # 0x7a2448
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d2bb
leaq 0x34a987(%rip), %rax    # 0x557c40
jmp 0x20d2ea
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d2cf
leaq 0x24553b(%rip), %rax    # 0x452808
jmp 0x20d2ea
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d2e3
leaq 0x8bf03(%rip), %rax     # 0x2991e4
jmp 0x20d2ea
leaq 0x15de1a(%rip), %rax    # 0x36b104
movq %rax, 0x59515f(%rip)    # 0x7a2450
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d344
leaq 0x3501ee(%rip), %rax    # 0x55d530
jmp 0x20d373
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d358
leaq 0x249a56(%rip), %rax    # 0x456dac
jmp 0x20d373
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d36c
leaq 0x8be7a(%rip), %rax     # 0x2991e4
jmp 0x20d373
leaq 0x162561(%rip), %rax    # 0x36f8d4
movq %rax, 0x5950de(%rip)    # 0x7a2458
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_64_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_64_pointer = parasail_nw_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_trace_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d3cd
leaq 0x3677b5(%rip), %rax    # 0x574b80
jmp 0x20d3fc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d3e1
leaq 0x25d8d1(%rip), %rax    # 0x46acb0
jmp 0x20d3fc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d3f5
leaq 0x8cb71(%rip), %rax     # 0x299f64
jmp 0x20d3fc
leaq 0x17817c(%rip), %rax    # 0x385578
movq %rax, 0x59505d(%rip)    # 0x7a2460
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_32_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_32_pointer = parasail_nw_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_trace_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d456
leaq 0x36a298(%rip), %rax    # 0x5776ec
jmp 0x20d485
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d46a
leaq 0x25f828(%rip), %rax    # 0x46cc90
jmp 0x20d485
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d47e
leaq 0x8cae8(%rip), %rax     # 0x299f64
jmp 0x20d485
leaq 0x17a2db(%rip), %rax    # 0x387760
movq %rax, 0x594fdc(%rip)    # 0x7a2468
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_16_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_16_pointer = parasail_nw_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_trace_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d4df
leaq 0x36bc87(%rip), %rax    # 0x579164
jmp 0x20d50e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d4f3
leaq 0x261103(%rip), %rax    # 0x46e5f4
jmp 0x20d50e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d507
leaq 0x8ca5f(%rip), %rax     # 0x299f64
jmp 0x20d50e
leaq 0x17bf22(%rip), %rax    # 0x389430
movq %rax, 0x594f5b(%rip)    # 0x7a2470
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_8_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_8_pointer = parasail_nw_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_trace_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d568
leaq 0x36d6c6(%rip), %rax    # 0x57ac2c
jmp 0x20d597
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d57c
leaq 0x262aea(%rip), %rax    # 0x470064
jmp 0x20d597
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d590
leaq 0x8c9d6(%rip), %rax     # 0x299f64
jmp 0x20d597
leaq 0x17d985(%rip), %rax    # 0x38af1c
movq %rax, 0x594eda(%rip)    # 0x7a2478
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_64_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_64_pointer = parasail_nw_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_trace_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d5f1
leaq 0x37e24d(%rip), %rax    # 0x58b83c
jmp 0x20d620
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d605
leaq 0x26e8bd(%rip), %rax    # 0x47bec0
jmp 0x20d620
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d619
leaq 0x8bbcd(%rip), %rax     # 0x2991e4
jmp 0x20d620
leaq 0x18abf8(%rip), %rax    # 0x398218
movq %rax, 0x594e59(%rip)    # 0x7a2480
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_32_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_32_pointer = parasail_nw_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_trace_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d67a
leaq 0x381464(%rip), %rax    # 0x58eadc
jmp 0x20d6a9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d68e
leaq 0x2713ac(%rip), %rax    # 0x47ea38
jmp 0x20d6a9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d6a2
leaq 0x8bb44(%rip), %rax     # 0x2991e4
jmp 0x20d6a9
leaq 0x18db0b(%rip), %rax    # 0x39b1b4
movq %rax, 0x594dd8(%rip)    # 0x7a2488
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_16_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_16_pointer = parasail_nw_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_trace_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20d703
leaq 0x38348b(%rip), %rax    # 0x590b8c
jmp 0x20d732
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d717
leaq 0x273343(%rip), %rax    # 0x480a58
jmp 0x20d732
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d72b
leaq 0x8babb(%rip), %rax     # 0x2991e4
jmp 0x20d732
leaq 0x18fe16(%rip), %rax    # 0x39d548
movq %rax, 0x594d57(%rip)    # 0x7a2490
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