LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_16_dispatcher
parasail_result_t* parasail_sw_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_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 0x1da5ae
leaq 0x7ce3fb(%rip), %rax    # 0x9a89a0
movq %rax, 0xc4d604(%rip)    # 0xe27bb0
jmp 0x1da5f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da5ca
leaq 0x496d5f(%rip), %rax    # 0x671320
movq %rax, 0xc4d5e8(%rip)    # 0xe27bb0
jmp 0x1da5f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da5e6
leaq 0x1b91a3(%rip), %rax    # 0x393780
movq %rax, 0xc4d5cc(%rip)    # 0xe27bb0
jmp 0x1da5f4
leaq 0xbf113(%rip), %rax     # 0x299700
movq %rax, 0xc4d5bc(%rip)    # 0xe27bb0
jmp 0x1da5f6
jmp 0x1da5f8
movq 0xc4d5b1(%rip), %rax    # 0xe27bb0
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/sw_dispatch.c
// Function: parasail_sw_table_scan_8_dispatcher
parasail_result_t* parasail_sw_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_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 0x1da66e
leaq 0x7d856b(%rip), %rax    # 0x9b2bd0
movq %rax, 0xc4d54c(%rip)    # 0xe27bb8
jmp 0x1da6b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da68a
leaq 0x49d56f(%rip), %rax    # 0x677bf0
movq %rax, 0xc4d530(%rip)    # 0xe27bb8
jmp 0x1da6b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da6a6
leaq 0x1bfd33(%rip), %rax    # 0x39a3d0
movq %rax, 0xc4d514(%rip)    # 0xe27bb8
jmp 0x1da6b4
leaq 0xbf053(%rip), %rax     # 0x299700
movq %rax, 0xc4d504(%rip)    # 0xe27bb8
jmp 0x1da6b6
jmp 0x1da6b8
movq 0xc4d4f9(%rip), %rax    # 0xe27bb8
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/sw_dispatch.c
// Function: parasail_sw_table_striped_64_dispatcher
parasail_result_t* parasail_sw_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1da72e
leaq 0x81362b(%rip), %rax    # 0x9edd50
movq %rax, 0xc4d494(%rip)    # 0xe27bc0
jmp 0x1da778
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da74a
leaq 0x4c333f(%rip), %rax    # 0x69da80
movq %rax, 0xc4d478(%rip)    # 0xe27bc0
jmp 0x1da776
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da766
leaq 0x1e6b13(%rip), %rax    # 0x3c1270
movq %rax, 0xc4d45c(%rip)    # 0xe27bc0
jmp 0x1da774
leaq 0xbd033(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d44c(%rip)    # 0xe27bc0
jmp 0x1da776
jmp 0x1da778
movq 0xc4d441(%rip), %rax    # 0xe27bc0
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/sw_dispatch.c
// Function: parasail_sw_table_striped_32_dispatcher
parasail_result_t* parasail_sw_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1da7ee
leaq 0x81917b(%rip), %rax    # 0x9f3960
movq %rax, 0xc4d3dc(%rip)    # 0xe27bc8
jmp 0x1da838
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da80a
leaq 0x4c803f(%rip), %rax    # 0x6a2840
movq %rax, 0xc4d3c0(%rip)    # 0xe27bc8
jmp 0x1da836
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da826
leaq 0x1eba53(%rip), %rax    # 0x3c6270
movq %rax, 0xc4d3a4(%rip)    # 0xe27bc8
jmp 0x1da834
leaq 0xbcf73(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d394(%rip)    # 0xe27bc8
jmp 0x1da836
jmp 0x1da838
movq 0xc4d389(%rip), %rax    # 0xe27bc8
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/sw_dispatch.c
// Function: parasail_sw_table_striped_16_dispatcher
parasail_result_t* parasail_sw_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1da8ae
leaq 0x81fb2b(%rip), %rax    # 0x9fa3d0
movq %rax, 0xc4d324(%rip)    # 0xe27bd0
jmp 0x1da8f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da8ca
leaq 0x4cd34f(%rip), %rax    # 0x6a7c10
movq %rax, 0xc4d308(%rip)    # 0xe27bd0
jmp 0x1da8f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da8e6
leaq 0x1f0e73(%rip), %rax    # 0x3cb750
movq %rax, 0xc4d2ec(%rip)    # 0xe27bd0
jmp 0x1da8f4
leaq 0xbceb3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d2dc(%rip)    # 0xe27bd0
jmp 0x1da8f6
jmp 0x1da8f8
movq 0xc4d2d1(%rip), %rax    # 0xe27bd0
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/sw_dispatch.c
// Function: parasail_sw_table_striped_8_dispatcher
parasail_result_t* parasail_sw_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1da96e
leaq 0x82822b(%rip), %rax    # 0xa02b90
movq %rax, 0xc4d26c(%rip)    # 0xe27bd8
jmp 0x1da9b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da98a
leaq 0x4d335f(%rip), %rax    # 0x6adce0
movq %rax, 0xc4d250(%rip)    # 0xe27bd8
jmp 0x1da9b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da9a6
leaq 0x1f71f3(%rip), %rax    # 0x3d1b90
movq %rax, 0xc4d234(%rip)    # 0xe27bd8
jmp 0x1da9b4
leaq 0xbcdf3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d224(%rip)    # 0xe27bd8
jmp 0x1da9b6
jmp 0x1da9b8
movq 0xc4d219(%rip), %rax    # 0xe27bd8
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/sw_dispatch.c
// Function: parasail_sw_table_diag_64_dispatcher
parasail_result_t* parasail_sw_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1daa2e
leaq 0x7e0c6b(%rip), %rax    # 0x9bb690
movq %rax, 0xc4d1b4(%rip)    # 0xe27be0
jmp 0x1daa78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1daa4a
leaq 0x4a303f(%rip), %rax    # 0x67da80
movq %rax, 0xc4d198(%rip)    # 0xe27be0
jmp 0x1daa76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1daa66
leaq 0x1c59a3(%rip), %rax    # 0x3a0400
movq %rax, 0xc4d17c(%rip)    # 0xe27be0
jmp 0x1daa74
leaq 0xbcd33(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d16c(%rip)    # 0xe27be0
jmp 0x1daa76
jmp 0x1daa78
movq 0xc4d161(%rip), %rax    # 0xe27be0
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/sw_dispatch.c
// Function: parasail_sw_table_diag_32_dispatcher
parasail_result_t* parasail_sw_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1daaee
leaq 0x7e968b(%rip), %rax    # 0x9c4170
movq %rax, 0xc4d0fc(%rip)    # 0xe27be8
jmp 0x1dab38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dab0a
leaq 0x4a90cf(%rip), %rax    # 0x683bd0
movq %rax, 0xc4d0e0(%rip)    # 0xe27be8
jmp 0x1dab36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dab26
leaq 0x1cbce3(%rip), %rax    # 0x3a6800
movq %rax, 0xc4d0c4(%rip)    # 0xe27be8
jmp 0x1dab34
leaq 0xbcc73(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d0b4(%rip)    # 0xe27be8
jmp 0x1dab36
jmp 0x1dab38
movq 0xc4d0a9(%rip), %rax    # 0xe27be8
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/sw_dispatch.c
// Function: parasail_sw_table_diag_16_dispatcher
parasail_result_t* parasail_sw_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1dabae
leaq 0x7f586b(%rip), %rax    # 0x9d0410
movq %rax, 0xc4d044(%rip)    # 0xe27bf0
jmp 0x1dabf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dabca
leaq 0x4b0aef(%rip), %rax    # 0x68b6b0
movq %rax, 0xc4d028(%rip)    # 0xe27bf0
jmp 0x1dabf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dabe6
leaq 0x1d3923(%rip), %rax    # 0x3ae500
movq %rax, 0xc4d00c(%rip)    # 0xe27bf0
jmp 0x1dabf4
leaq 0xbcbb3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4cffc(%rip)    # 0xe27bf0
jmp 0x1dabf6
jmp 0x1dabf8
movq 0xc4cff1(%rip), %rax    # 0xe27bf0
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/sw_dispatch.c
// Function: parasail_sw_table_diag_8_dispatcher
parasail_result_t* parasail_sw_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_table_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 0x1dac6e
leaq 0x80846b(%rip), %rax    # 0x9e30d0
movq %rax, 0xc4cf8c(%rip)    # 0xe27bf8
jmp 0x1dacb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dac8a
leaq 0x4bb63f(%rip), %rax    # 0x6962c0
movq %rax, 0xc4cf70(%rip)    # 0xe27bf8
jmp 0x1dacb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1daca6
leaq 0x1deae3(%rip), %rax    # 0x3b9780
movq %rax, 0xc4cf54(%rip)    # 0xe27bf8
jmp 0x1dacb4
leaq 0xbcaf3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4cf44(%rip)    # 0xe27bf8
jmp 0x1dacb6
jmp 0x1dacb8
movq 0xc4cf39(%rip), %rax    # 0xe27bf8
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sw_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_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 0x1dad2e
leaq 0x833d9b(%rip), %rax    # 0xa0eac0
movq %rax, 0xc4ced4(%rip)    # 0xe27c00
jmp 0x1dad78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dad4a
leaq 0x4de0af(%rip), %rax    # 0x6b8df0
movq %rax, 0xc4ceb8(%rip)    # 0xe27c00
jmp 0x1dad76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dad66
leaq 0x1ffdb3(%rip), %rax    # 0x3dab10
movq %rax, 0xc4ce9c(%rip)    # 0xe27c00
jmp 0x1dad74
leaq 0xbe993(%rip), %rax     # 0x299700
movq %rax, 0xc4ce8c(%rip)    # 0xe27c00
jmp 0x1dad76
jmp 0x1dad78
movq 0xc4ce81(%rip), %rax    # 0xe27c00
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sw_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_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 0x1dadee
leaq 0x84170b(%rip), %rax    # 0xa1c4f0
movq %rax, 0xc4ce1c(%rip)    # 0xe27c08
jmp 0x1dae38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dae0a
leaq 0x4e8f2f(%rip), %rax    # 0x6c3d30
movq %rax, 0xc4ce00(%rip)    # 0xe27c08
jmp 0x1dae36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dae26
leaq 0x209f83(%rip), %rax    # 0x3e4da0
movq %rax, 0xc4cde4(%rip)    # 0xe27c08
jmp 0x1dae34
leaq 0xbe8d3(%rip), %rax     # 0x299700
movq %rax, 0xc4cdd4(%rip)    # 0xe27c08
jmp 0x1dae36
jmp 0x1dae38
movq 0xc4cdc9(%rip), %rax    # 0xe27c08
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sw_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_table_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 0x1daeae
leaq 0x850b3b(%rip), %rax    # 0xa2b9e0
movq %rax, 0xc4cd64(%rip)    # 0xe27c10
jmp 0x1daef8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1daeca
leaq 0x4f468f(%rip), %rax    # 0x6cf550
movq %rax, 0xc4cd48(%rip)    # 0xe27c10
jmp 0x1daef6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1daee6
leaq 0x214963(%rip), %rax    # 0x3ef840
movq %rax, 0xc4cd2c(%rip)    # 0xe27c10
jmp 0x1daef4
leaq 0xbe813(%rip), %rax     # 0x299700
movq %rax, 0xc4cd1c(%rip)    # 0xe27c10
jmp 0x1daef6
jmp 0x1daef8
movq 0xc4cd11(%rip), %rax    # 0xe27c10
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sw_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_table_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 0x1daf6e
leaq 0x86310b(%rip), %rax    # 0xa3e070
movq %rax, 0xc4ccac(%rip)    # 0xe27c18
jmp 0x1dafb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1daf8a
leaq 0x500d2f(%rip), %rax    # 0x6dbcb0
movq %rax, 0xc4cc90(%rip)    # 0xe27c18
jmp 0x1dafb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dafa6
leaq 0x2204a3(%rip), %rax    # 0x3fb440
movq %rax, 0xc4cc74(%rip)    # 0xe27c18
jmp 0x1dafb4
leaq 0xbe753(%rip), %rax     # 0x299700
movq %rax, 0xc4cc64(%rip)    # 0xe27c18
jmp 0x1dafb6
jmp 0x1dafb8
movq 0xc4cc59(%rip), %rax    # 0xe27c18
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/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sw_stats_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_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 0x1db02e
leaq 0x8ba9fb(%rip), %rax    # 0xa95a20
movq %rax, 0xc4cbf4(%rip)    # 0xe27c20
jmp 0x1db078
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db04a
leaq 0x53c7cf(%rip), %rax    # 0x717810
movq %rax, 0xc4cbd8(%rip)    # 0xe27c20
jmp 0x1db076
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db066
leaq 0x25a3e3(%rip), %rax    # 0x435440
movq %rax, 0xc4cbbc(%rip)    # 0xe27c20
jmp 0x1db074
leaq 0xbc733(%rip), %rax     # 0x2977a0
movq %rax, 0xc4cbac(%rip)    # 0xe27c20
jmp 0x1db076
jmp 0x1db078
movq 0xc4cba1(%rip), %rax    # 0xe27c20
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/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sw_stats_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_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 0x1db0ee
leaq 0x8c625b(%rip), %rax    # 0xaa1340
movq %rax, 0xc4cb3c(%rip)    # 0xe27c28
jmp 0x1db138
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db10a
leaq 0x54621f(%rip), %rax    # 0x721320
movq %rax, 0xc4cb20(%rip)    # 0xe27c28
jmp 0x1db136
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db126
leaq 0x263803(%rip), %rax    # 0x43e920
movq %rax, 0xc4cb04(%rip)    # 0xe27c28
jmp 0x1db134
leaq 0xbc673(%rip), %rax     # 0x2977a0
movq %rax, 0xc4caf4(%rip)    # 0xe27c28
jmp 0x1db136
jmp 0x1db138
movq 0xc4cae9(%rip), %rax    # 0xe27c28
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/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sw_stats_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_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 0x1db1ae
leaq 0x8d2c3b(%rip), %rax    # 0xaadde0
movq %rax, 0xc4ca84(%rip)    # 0xe27c30
jmp 0x1db1f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db1ca
leaq 0x55044f(%rip), %rax    # 0x72b610
movq %rax, 0xc4ca68(%rip)    # 0xe27c30
jmp 0x1db1f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db1e6
leaq 0x26d213(%rip), %rax    # 0x4483f0
movq %rax, 0xc4ca4c(%rip)    # 0xe27c30
jmp 0x1db1f4
leaq 0xbc5b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4ca3c(%rip)    # 0xe27c30
jmp 0x1db1f6
jmp 0x1db1f8
movq 0xc4ca31(%rip), %rax    # 0xe27c30
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/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sw_stats_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_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 0x1db26e
leaq 0x8e19bb(%rip), %rax    # 0xabcc20
movq %rax, 0xc4c9cc(%rip)    # 0xe27c38
jmp 0x1db2b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db28a
leaq 0x55b7ff(%rip), %rax    # 0x736a80
movq %rax, 0xc4c9b0(%rip)    # 0xe27c38
jmp 0x1db2b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db2a6
leaq 0x277e03(%rip), %rax    # 0x4530a0
movq %rax, 0xc4c994(%rip)    # 0xe27c38
jmp 0x1db2b4
leaq 0xbc4f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c984(%rip)    # 0xe27c38
jmp 0x1db2b6
jmp 0x1db2b8
movq 0xc4c979(%rip), %rax    # 0xe27c38
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/sw_dispatch.c
// Function: parasail_sw_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sw_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_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 0x1db32e
leaq 0x871c4b(%rip), %rax    # 0xa4cf70
movq %rax, 0xc4c914(%rip)    # 0xe27c40
jmp 0x1db378
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db34a
leaq 0x50b29f(%rip), %rax    # 0x6e65e0
movq %rax, 0xc4c8f8(%rip)    # 0xe27c40
jmp 0x1db376
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db366
leaq 0x22a173(%rip), %rax    # 0x4054d0
movq %rax, 0xc4c8dc(%rip)    # 0xe27c40
jmp 0x1db374
leaq 0xbc433(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c8cc(%rip)    # 0xe27c40
jmp 0x1db376
jmp 0x1db378
movq 0xc4c8c1(%rip), %rax    # 0xe27c40
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/sw_dispatch.c
// Function: parasail_sw_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sw_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_diag_32_pointer = parasail_sw_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_diag_32_pointer = parasail_sw_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_diag_32_pointer = parasail_sw_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_diag_32_pointer = parasail_sw_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_diag_32_pointer = parasail_sw_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_table_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_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 0x1db3ee
leaq 0x87f85b(%rip), %rax    # 0xa5ac40
movq %rax, 0xc4c85c(%rip)    # 0xe27c48
jmp 0x1db438
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db40a
leaq 0x51534f(%rip), %rax    # 0x6f0750
movq %rax, 0xc4c840(%rip)    # 0xe27c48
jmp 0x1db436
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db426
leaq 0x233cb3(%rip), %rax    # 0x40f0d0
movq %rax, 0xc4c824(%rip)    # 0xe27c48
jmp 0x1db434
leaq 0xbc373(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c814(%rip)    # 0xe27c48
jmp 0x1db436
jmp 0x1db438
movq 0xc4c809(%rip), %rax    # 0xe27c48
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)