LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_16_dispatcher
parasail_result_t* parasail_nw_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_striped_16_pointer = parasail_nw_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7b2e
leaq 0x70e36b(%rip), %rax    # 0x8d5e90
movq %rax, 0xc5f724(%rip)    # 0xe27250
jmp 0x1c7b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7b4a
leaq 0x40c65f(%rip), %rax    # 0x5d41a0
movq %rax, 0xc5f708(%rip)    # 0xe27250
jmp 0x1c7b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7b66
leaq 0x133cb3(%rip), %rax    # 0x2fb810
movq %rax, 0xc5f6ec(%rip)    # 0xe27250
jmp 0x1c7b74
leaq 0xce5e3(%rip), %rax     # 0x296150
movq %rax, 0xc5f6dc(%rip)    # 0xe27250
jmp 0x1c7b76
jmp 0x1c7b78
movq 0xc5f6d1(%rip), %rax    # 0xe27250
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_8_dispatcher
parasail_result_t* parasail_nw_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_striped_8_pointer = parasail_nw_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7bee
leaq 0x71482b(%rip), %rax    # 0x8dc410
movq %rax, 0xc5f66c(%rip)    # 0xe27258
jmp 0x1c7c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7c0a
leaq 0x41176f(%rip), %rax    # 0x5d9370
movq %rax, 0xc5f650(%rip)    # 0xe27258
jmp 0x1c7c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7c26
leaq 0x138f43(%rip), %rax    # 0x300b60
movq %rax, 0xc5f634(%rip)    # 0xe27258
jmp 0x1c7c34
leaq 0xce523(%rip), %rax     # 0x296150
movq %rax, 0xc5f624(%rip)    # 0xe27258
jmp 0x1c7c36
jmp 0x1c7c38
movq 0xc5f619(%rip), %rax    # 0xe27258
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_64_dispatcher
parasail_result_t* parasail_nw_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_diag_64_pointer = parasail_nw_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7cae
leaq 0x6d507b(%rip), %rax    # 0x89cd20
movq %rax, 0xc5f5b4(%rip)    # 0xe27260
jmp 0x1c7cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7cca
leaq 0x3e524f(%rip), %rax    # 0x5acf10
movq %rax, 0xc5f598(%rip)    # 0xe27260
jmp 0x1c7cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7ce6
leaq 0x10b9e3(%rip), %rax    # 0x2d36c0
movq %rax, 0xc5f57c(%rip)    # 0xe27260
jmp 0x1c7cf4
leaq 0xce463(%rip), %rax     # 0x296150
movq %rax, 0xc5f56c(%rip)    # 0xe27260
jmp 0x1c7cf6
jmp 0x1c7cf8
movq 0xc5f561(%rip), %rax    # 0xe27260
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_32_dispatcher
parasail_result_t* parasail_nw_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_diag_32_pointer = parasail_nw_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7d6e
leaq 0x6dc35b(%rip), %rax    # 0x8a40c0
movq %rax, 0xc5f4fc(%rip)    # 0xe27268
jmp 0x1c7db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7d8a
leaq 0x3ea8df(%rip), %rax    # 0x5b2660
movq %rax, 0xc5f4e0(%rip)    # 0xe27268
jmp 0x1c7db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7da6
leaq 0x111113(%rip), %rax    # 0x2d8eb0
movq %rax, 0xc5f4c4(%rip)    # 0xe27268
jmp 0x1c7db4
leaq 0xce3a3(%rip), %rax     # 0x296150
movq %rax, 0xc5f4b4(%rip)    # 0xe27268
jmp 0x1c7db6
jmp 0x1c7db8
movq 0xc5f4a9(%rip), %rax    # 0xe27268
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_16_dispatcher
parasail_result_t* parasail_nw_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_diag_16_pointer = parasail_nw_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7e2e
leaq 0x6e4a2b(%rip), %rax    # 0x8ac850
movq %rax, 0xc5f444(%rip)    # 0xe27270
jmp 0x1c7e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7e4a
leaq 0x3f076f(%rip), %rax    # 0x5b85b0
movq %rax, 0xc5f428(%rip)    # 0xe27270
jmp 0x1c7e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7e66
leaq 0x117243(%rip), %rax    # 0x2df0a0
movq %rax, 0xc5f40c(%rip)    # 0xe27270
jmp 0x1c7e74
leaq 0xce2e3(%rip), %rax     # 0x296150
movq %rax, 0xc5f3fc(%rip)    # 0xe27270
jmp 0x1c7e76
jmp 0x1c7e78
movq 0xc5f3f1(%rip), %rax    # 0xe27270
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_8_dispatcher
parasail_result_t* parasail_nw_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_diag_8_pointer = parasail_nw_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7eee
leaq 0x6f0a6b(%rip), %rax    # 0x8b8950
movq %rax, 0xc5f38c(%rip)    # 0xe27278
jmp 0x1c7f38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7f0a
leaq 0x3f80cf(%rip), %rax    # 0x5bffd0
movq %rax, 0xc5f370(%rip)    # 0xe27278
jmp 0x1c7f36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7f26
leaq 0x11ed43(%rip), %rax    # 0x2e6c60
movq %rax, 0xc5f354(%rip)    # 0xe27278
jmp 0x1c7f34
leaq 0xce223(%rip), %rax     # 0x296150
movq %rax, 0xc5f344(%rip)    # 0xe27278
jmp 0x1c7f36
jmp 0x1c7f38
movq 0xc5f339(%rip), %rax    # 0xe27278
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_64_dispatcher
parasail_result_t* parasail_nw_stats_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_scan_64_pointer = parasail_nw_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7fae
leaq 0x71be9b(%rip), %rax    # 0x8e3e40
movq %rax, 0xc5f2d4(%rip)    # 0xe27280
jmp 0x1c7ff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7fca
leaq 0x41863f(%rip), %rax    # 0x5e0600
movq %rax, 0xc5f2b8(%rip)    # 0xe27280
jmp 0x1c7ff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7fe6
leaq 0x13e8e3(%rip), %rax    # 0x3068c0
movq %rax, 0xc5f29c(%rip)    # 0xe27280
jmp 0x1c7ff4
leaq 0xcfef3(%rip), %rax     # 0x297ee0
movq %rax, 0xc5f28c(%rip)    # 0xe27280
jmp 0x1c7ff6
jmp 0x1c7ff8
movq 0xc5f281(%rip), %rax    # 0xe27280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_32_dispatcher
parasail_result_t* parasail_nw_stats_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_scan_32_pointer = parasail_nw_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c806e
leaq 0x7289cb(%rip), %rax    # 0x8f0a30
movq %rax, 0xc5f21c(%rip)    # 0xe27288
jmp 0x1c80b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c808a
leaq 0x422d6f(%rip), %rax    # 0x5eadf0
movq %rax, 0xc5f200(%rip)    # 0xe27288
jmp 0x1c80b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c80a6
leaq 0x1483d3(%rip), %rax    # 0x310470
movq %rax, 0xc5f1e4(%rip)    # 0xe27288
jmp 0x1c80b4
leaq 0xcfe33(%rip), %rax     # 0x297ee0
movq %rax, 0xc5f1d4(%rip)    # 0xe27288
jmp 0x1c80b6
jmp 0x1c80b8
movq 0xc5f1c9(%rip), %rax    # 0xe27288
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_16_dispatcher
parasail_result_t* parasail_nw_stats_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_scan_16_pointer = parasail_nw_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c812e
leaq 0x735fdb(%rip), %rax    # 0x8fe100
movq %rax, 0xc5f164(%rip)    # 0xe27290
jmp 0x1c8178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c814a
leaq 0x42d82f(%rip), %rax    # 0x5f5970
movq %rax, 0xc5f148(%rip)    # 0xe27290
jmp 0x1c8176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c8166
leaq 0x1520a3(%rip), %rax    # 0x31a200
movq %rax, 0xc5f12c(%rip)    # 0xe27290
jmp 0x1c8174
leaq 0xcfd73(%rip), %rax     # 0x297ee0
movq %rax, 0xc5f11c(%rip)    # 0xe27290
jmp 0x1c8176
jmp 0x1c8178
movq 0xc5f111(%rip), %rax    # 0xe27290
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_8_dispatcher
parasail_result_t* parasail_nw_stats_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_scan_8_pointer = parasail_nw_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c81ee
leaq 0x74507b(%rip), %rax    # 0x90d260
movq %rax, 0xc5f0ac(%rip)    # 0xe27298
jmp 0x1c8238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c820a
leaq 0x438b4f(%rip), %rax    # 0x600d50
movq %rax, 0xc5f090(%rip)    # 0xe27298
jmp 0x1c8236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c8226
leaq 0x15c673(%rip), %rax    # 0x324890
movq %rax, 0xc5f074(%rip)    # 0xe27298
jmp 0x1c8234
leaq 0xcfcb3(%rip), %rax     # 0x297ee0
movq %rax, 0xc5f064(%rip)    # 0xe27298
jmp 0x1c8236
jmp 0x1c8238
movq 0xc5f059(%rip), %rax    # 0xe27298
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_64_dispatcher
parasail_result_t* parasail_nw_stats_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_striped_64_pointer = parasail_nw_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c82ae
leaq 0x79a8eb(%rip), %rax    # 0x962b90
movq %rax, 0xc5eff4(%rip)    # 0xe272a0
jmp 0x1c82f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c82ca
leaq 0x4729ef(%rip), %rax    # 0x63acb0
movq %rax, 0xc5efd8(%rip)    # 0xe272a0
jmp 0x1c82f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c82e6
leaq 0x194553(%rip), %rax    # 0x35c830
movq %rax, 0xc5efbc(%rip)    # 0xe272a0
jmp 0x1c82f4
leaq 0xcde63(%rip), %rax     # 0x296150
movq %rax, 0xc5efac(%rip)    # 0xe272a0
jmp 0x1c82f6
jmp 0x1c82f8
movq 0xc5efa1(%rip), %rax    # 0xe272a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_32_dispatcher
parasail_result_t* parasail_nw_stats_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_striped_32_pointer = parasail_nw_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c836e
leaq 0x7a54ab(%rip), %rax    # 0x96d810
movq %rax, 0xc5ef3c(%rip)    # 0xe272a8
jmp 0x1c83b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c838a
leaq 0x47bdbf(%rip), %rax    # 0x644140
movq %rax, 0xc5ef20(%rip)    # 0xe272a8
jmp 0x1c83b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c83a6
leaq 0x19d233(%rip), %rax    # 0x3655d0
movq %rax, 0xc5ef04(%rip)    # 0xe272a8
jmp 0x1c83b4
leaq 0xcdda3(%rip), %rax     # 0x296150
movq %rax, 0xc5eef4(%rip)    # 0xe272a8
jmp 0x1c83b6
jmp 0x1c83b8
movq 0xc5eee9(%rip), %rax    # 0xe272a8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_16_dispatcher
parasail_result_t* parasail_nw_stats_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_striped_16_pointer = parasail_nw_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c842e
leaq 0x7b06fb(%rip), %rax    # 0x978b20
movq %rax, 0xc5ee84(%rip)    # 0xe272b0
jmp 0x1c8478
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c844a
leaq 0x48530f(%rip), %rax    # 0x64d750
movq %rax, 0xc5ee68(%rip)    # 0xe272b0
jmp 0x1c8476
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c8466
leaq 0x1a5f93(%rip), %rax    # 0x36e3f0
movq %rax, 0xc5ee4c(%rip)    # 0xe272b0
jmp 0x1c8474
leaq 0xcdce3(%rip), %rax     # 0x296150
movq %rax, 0xc5ee3c(%rip)    # 0xe272b0
jmp 0x1c8476
jmp 0x1c8478
movq 0xc5ee31(%rip), %rax    # 0xe272b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_8_dispatcher
parasail_result_t* parasail_nw_stats_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_striped_8_pointer = parasail_nw_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c84ee
leaq 0x7bcc3b(%rip), %rax    # 0x985120
movq %rax, 0xc5edcc(%rip)    # 0xe272b8
jmp 0x1c8538
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c850a
leaq 0x48f38f(%rip), %rax    # 0x657890
movq %rax, 0xc5edb0(%rip)    # 0xe272b8
jmp 0x1c8536
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c8526
leaq 0x1af673(%rip), %rax    # 0x377b90
movq %rax, 0xc5ed94(%rip)    # 0xe272b8
jmp 0x1c8534
leaq 0xcdc23(%rip), %rax     # 0x296150
movq %rax, 0xc5ed84(%rip)    # 0xe272b8
jmp 0x1c8536
jmp 0x1c8538
movq 0xc5ed79(%rip), %rax    # 0xe272b8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_64_dispatcher
parasail_result_t* parasail_nw_stats_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_diag_64_pointer = parasail_nw_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c85ae
leaq 0x756c3b(%rip), %rax    # 0x91f1e0
movq %rax, 0xc5ed14(%rip)    # 0xe272c0
jmp 0x1c85f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c85ca
leaq 0x44478f(%rip), %rax    # 0x60cd50
movq %rax, 0xc5ecf8(%rip)    # 0xe272c0
jmp 0x1c85f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c85e6
leaq 0x167713(%rip), %rax    # 0x32fcf0
movq %rax, 0xc5ecdc(%rip)    # 0xe272c0
jmp 0x1c85f4
leaq 0xcdb63(%rip), %rax     # 0x296150
movq %rax, 0xc5eccc(%rip)    # 0xe272c0
jmp 0x1c85f6
jmp 0x1c85f8
movq 0xc5ecc1(%rip), %rax    # 0xe272c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_32_dispatcher
parasail_result_t* parasail_nw_stats_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_diag_32_pointer = parasail_nw_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c866e
leaq 0x762cdb(%rip), %rax    # 0x92b340
movq %rax, 0xc5ec5c(%rip)    # 0xe272c8
jmp 0x1c86b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c868a
leaq 0x44db1f(%rip), %rax    # 0x6161a0
movq %rax, 0xc5ec40(%rip)    # 0xe272c8
jmp 0x1c86b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c86a6
leaq 0x170373(%rip), %rax    # 0x338a10
movq %rax, 0xc5ec24(%rip)    # 0xe272c8
jmp 0x1c86b4
leaq 0xcdaa3(%rip), %rax     # 0x296150
movq %rax, 0xc5ec14(%rip)    # 0xe272c8
jmp 0x1c86b6
jmp 0x1c86b8
movq 0xc5ec09(%rip), %rax    # 0xe272c8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_16_dispatcher
parasail_result_t* parasail_nw_stats_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_diag_16_pointer = parasail_nw_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c872e
leaq 0x7703cb(%rip), %rax    # 0x938af0
movq %rax, 0xc5eba4(%rip)    # 0xe272d0
jmp 0x1c8778
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c874a
leaq 0x45782f(%rip), %rax    # 0x61ff70
movq %rax, 0xc5eb88(%rip)    # 0xe272d0
jmp 0x1c8776
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c8766
leaq 0x179b13(%rip), %rax    # 0x342270
movq %rax, 0xc5eb6c(%rip)    # 0xe272d0
jmp 0x1c8774
leaq 0xcd9e3(%rip), %rax     # 0x296150
movq %rax, 0xc5eb5c(%rip)    # 0xe272d0
jmp 0x1c8776
jmp 0x1c8778
movq 0xc5eb51(%rip), %rax    # 0xe272d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_8_dispatcher
parasail_result_t* parasail_nw_stats_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_diag_8_pointer = parasail_nw_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c87ee
leaq 0x7819ab(%rip), %rax    # 0x94a190
movq %rax, 0xc5eaec(%rip)    # 0xe272d8
jmp 0x1c8838
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c880a
leaq 0x46329f(%rip), %rax    # 0x62baa0
movq %rax, 0xc5ead0(%rip)    # 0xe272d8
jmp 0x1c8836
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c8826
leaq 0x184e23(%rip), %rax    # 0x34d640
movq %rax, 0xc5eab4(%rip)    # 0xe272d8
jmp 0x1c8834
leaq 0xcd923(%rip), %rax     # 0x296150
movq %rax, 0xc5eaa4(%rip)    # 0xe272d8
jmp 0x1c8836
jmp 0x1c8838
movq 0xc5ea99(%rip), %rax    # 0xe272d8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_scan_64_dispatcher
parasail_result_t* parasail_nw_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_table_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c88ae
leaq 0x7cd0cb(%rip), %rax    # 0x995970
movq %rax, 0xc5ea34(%rip)    # 0xe272e0
jmp 0x1c88f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c88ca
leaq 0x499b1f(%rip), %rax    # 0x6623e0
movq %rax, 0xc5ea18(%rip)    # 0xe272e0
jmp 0x1c88f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c88e6
leaq 0x1bb993(%rip), %rax    # 0x384270
movq %rax, 0xc5e9fc(%rip)    # 0xe272e0
jmp 0x1c88f4
leaq 0xcf5f3(%rip), %rax     # 0x297ee0
movq %rax, 0xc5e9ec(%rip)    # 0xe272e0
jmp 0x1c88f6
jmp 0x1c88f8
movq 0xc5e9e1(%rip), %rax    # 0xe272e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_scan_32_dispatcher
parasail_result_t* parasail_nw_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_table_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c896e
leaq 0x7d349b(%rip), %rax    # 0x99be00
movq %rax, 0xc5e97c(%rip)    # 0xe272e8
jmp 0x1c89b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c898a
leaq 0x49ee6f(%rip), %rax    # 0x6677f0
movq %rax, 0xc5e960(%rip)    # 0xe272e8
jmp 0x1c89b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c89a6
leaq 0x1c0f23(%rip), %rax    # 0x3898c0
movq %rax, 0xc5e944(%rip)    # 0xe272e8
jmp 0x1c89b4
leaq 0xcf533(%rip), %rax     # 0x297ee0
movq %rax, 0xc5e934(%rip)    # 0xe272e8
jmp 0x1c89b6
jmp 0x1c89b8
movq 0xc5e929(%rip), %rax    # 0xe272e8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)