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_striped_16_dispatcher
parasail_result_t* parasail_sw_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_striped_16_pointer = parasail_sw_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d96ae
leaq 0x700ffb(%rip), %rax    # 0x8da6a0
movq %rax, 0xc4e464(%rip)    # 0xe27b10
jmp 0x1d96f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d96ca
leaq 0x3fe61f(%rip), %rax    # 0x5d7ce0
movq %rax, 0xc4e448(%rip)    # 0xe27b10
jmp 0x1d96f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d96e6
leaq 0x125d53(%rip), %rax    # 0x2ff430
movq %rax, 0xc4e42c(%rip)    # 0xe27b10
jmp 0x1d96f4
leaq 0xbe0b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e41c(%rip)    # 0xe27b10
jmp 0x1d96f6
jmp 0x1d96f8
movq 0xc4e411(%rip), %rax    # 0xe27b10
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_striped_8_dispatcher
parasail_result_t* parasail_sw_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_striped_8_pointer = parasail_sw_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d976e
leaq 0x70817b(%rip), %rax    # 0x8e18e0
movq %rax, 0xc4e3ac(%rip)    # 0xe27b18
jmp 0x1d97b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d978a
leaq 0x403bff(%rip), %rax    # 0x5dd380
movq %rax, 0xc4e390(%rip)    # 0xe27b18
jmp 0x1d97b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d97a6
leaq 0x12b633(%rip), %rax    # 0x304dd0
movq %rax, 0xc4e374(%rip)    # 0xe27b18
jmp 0x1d97b4
leaq 0xbdff3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e364(%rip)    # 0xe27b18
jmp 0x1d97b6
jmp 0x1d97b8
movq 0xc4e359(%rip), %rax    # 0xe27b18
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_diag_64_dispatcher
parasail_result_t* parasail_sw_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_diag_64_pointer = parasail_sw_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d982e
leaq 0x6c853b(%rip), %rax    # 0x8a1d60
movq %rax, 0xc4e2f4(%rip)    # 0xe27b20
jmp 0x1d9878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d984a
leaq 0x3d73af(%rip), %rax    # 0x5b0bf0
movq %rax, 0xc4e2d8(%rip)    # 0xe27b20
jmp 0x1d9876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9866
leaq 0xfdbd3(%rip), %rax     # 0x2d7430
movq %rax, 0xc4e2bc(%rip)    # 0xe27b20
jmp 0x1d9874
leaq 0xbdf33(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e2ac(%rip)    # 0xe27b20
jmp 0x1d9876
jmp 0x1d9878
movq 0xc4e2a1(%rip), %rax    # 0xe27b20
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_diag_32_dispatcher
parasail_result_t* parasail_sw_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_diag_32_pointer = parasail_sw_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d98ee
leaq 0x6d05eb(%rip), %rax    # 0x8a9ed0
movq %rax, 0xc4e23c(%rip)    # 0xe27b28
jmp 0x1d9938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d990a
leaq 0x3dcf6f(%rip), %rax    # 0x5b6870
movq %rax, 0xc4e220(%rip)    # 0xe27b28
jmp 0x1d9936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9926
leaq 0x1039b3(%rip), %rax    # 0x2dd2d0
movq %rax, 0xc4e204(%rip)    # 0xe27b28
jmp 0x1d9934
leaq 0xbde73(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e1f4(%rip)    # 0xe27b28
jmp 0x1d9936
jmp 0x1d9938
movq 0xc4e1e9(%rip), %rax    # 0xe27b28
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_diag_16_dispatcher
parasail_result_t* parasail_sw_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_diag_16_pointer = parasail_sw_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d99ae
leaq 0x6db4db(%rip), %rax    # 0x8b4e80
movq %rax, 0xc4e184(%rip)    # 0xe27b30
jmp 0x1d99f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d99ca
leaq 0x3e409f(%rip), %rax    # 0x5bda60
movq %rax, 0xc4e168(%rip)    # 0xe27b30
jmp 0x1d99f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d99e6
leaq 0x10acc3(%rip), %rax    # 0x2e46a0
movq %rax, 0xc4e14c(%rip)    # 0xe27b30
jmp 0x1d99f4
leaq 0xbddb3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e13c(%rip)    # 0xe27b30
jmp 0x1d99f6
jmp 0x1d99f8
movq 0xc4e131(%rip), %rax    # 0xe27b30
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_diag_8_dispatcher
parasail_result_t* parasail_sw_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_diag_8_pointer = parasail_sw_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d9a6e
leaq 0x6ebbcb(%rip), %rax    # 0x8c5630
movq %rax, 0xc4e0cc(%rip)    # 0xe27b38
jmp 0x1d9ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9a8a
leaq 0x3edabf(%rip), %rax    # 0x5c7540
movq %rax, 0xc4e0b0(%rip)    # 0xe27b38
jmp 0x1d9ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9aa6
leaq 0x114cf3(%rip), %rax    # 0x2ee790
movq %rax, 0xc4e094(%rip)    # 0xe27b38
jmp 0x1d9ab4
leaq 0xbdcf3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e084(%rip)    # 0xe27b38
jmp 0x1d9ab6
jmp 0x1d9ab8
movq 0xc4e079(%rip), %rax    # 0xe27b38
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_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_64_pointer = parasail_sw_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d9b2e
leaq 0x712fbb(%rip), %rax    # 0x8ecae0
movq %rax, 0xc4e014(%rip)    # 0xe27b40
jmp 0x1d9b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9b4a
leaq 0x40df3f(%rip), %rax    # 0x5e7a80
movq %rax, 0xc4dff8(%rip)    # 0xe27b40
jmp 0x1d9b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9b66
leaq 0x133a83(%rip), %rax    # 0x30d5e0
movq %rax, 0xc4dfdc(%rip)    # 0xe27b40
jmp 0x1d9b74
leaq 0xbfb93(%rip), %rax     # 0x299700
movq %rax, 0xc4dfcc(%rip)    # 0xe27b40
jmp 0x1d9b76
jmp 0x1d9b78
movq 0xc4dfc1(%rip), %rax    # 0xe27b40
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_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_32_pointer = parasail_sw_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d9bee
leaq 0x7201ab(%rip), %rax    # 0x8f9d90
movq %rax, 0xc4df5c(%rip)    # 0xe27b48
jmp 0x1d9c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9c0a
leaq 0x4188cf(%rip), %rax    # 0x5f24d0
movq %rax, 0xc4df40(%rip)    # 0xe27b48
jmp 0x1d9c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9c26
leaq 0x13d6b3(%rip), %rax    # 0x3172d0
movq %rax, 0xc4df24(%rip)    # 0xe27b48
jmp 0x1d9c34
leaq 0xbfad3(%rip), %rax     # 0x299700
movq %rax, 0xc4df14(%rip)    # 0xe27b48
jmp 0x1d9c36
jmp 0x1d9c38
movq 0xc4df09(%rip), %rax    # 0xe27b48
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_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_16_pointer = parasail_sw_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d9cae
leaq 0x72e95b(%rip), %rax    # 0x908600
movq %rax, 0xc4dea4(%rip)    # 0xe27b50
jmp 0x1d9cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9cca
leaq 0x42393f(%rip), %rax    # 0x5fd600
movq %rax, 0xc4de88(%rip)    # 0xe27b50
jmp 0x1d9cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9ce6
leaq 0x147953(%rip), %rax    # 0x321630
movq %rax, 0xc4de6c(%rip)    # 0xe27b50
jmp 0x1d9cf4
leaq 0xbfa13(%rip), %rax     # 0x299700
movq %rax, 0xc4de5c(%rip)    # 0xe27b50
jmp 0x1d9cf6
jmp 0x1d9cf8
movq 0xc4de51(%rip), %rax    # 0xe27b50
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_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_8_pointer = parasail_sw_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d9d6e
leaq 0x73f88b(%rip), %rax    # 0x9195f0
movq %rax, 0xc4ddec(%rip)    # 0xe27b58
jmp 0x1d9db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9d8a
leaq 0x42f46f(%rip), %rax    # 0x6091f0
movq %rax, 0xc4ddd0(%rip)    # 0xe27b58
jmp 0x1d9db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9da6
leaq 0x1528c3(%rip), %rax    # 0x32c660
movq %rax, 0xc4ddb4(%rip)    # 0xe27b58
jmp 0x1d9db4
leaq 0xbf953(%rip), %rax     # 0x299700
movq %rax, 0xc4dda4(%rip)    # 0xe27b58
jmp 0x1d9db6
jmp 0x1d9db8
movq 0xc4dd99(%rip), %rax    # 0xe27b58
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_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_64_pointer = parasail_sw_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d9e2e
leaq 0x7904fb(%rip), %rax    # 0x96a320
movq %rax, 0xc4dd34(%rip)    # 0xe27b60
jmp 0x1d9e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9e4a
leaq 0x4675ef(%rip), %rax    # 0x641430
movq %rax, 0xc4dd18(%rip)    # 0xe27b60
jmp 0x1d9e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9e66
leaq 0x188cb3(%rip), %rax    # 0x362b10
movq %rax, 0xc4dcfc(%rip)    # 0xe27b60
jmp 0x1d9e74
leaq 0xbd933(%rip), %rax     # 0x2977a0
movq %rax, 0xc4dcec(%rip)    # 0xe27b60
jmp 0x1d9e76
jmp 0x1d9e78
movq 0xc4dce1(%rip), %rax    # 0xe27b60
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_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_32_pointer = parasail_sw_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d9eee
leaq 0x79b3fb(%rip), %rax    # 0x9752e0
movq %rax, 0xc4dc7c(%rip)    # 0xe27b68
jmp 0x1d9f38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9f0a
leaq 0x4709cf(%rip), %rax    # 0x64a8d0
movq %rax, 0xc4dc60(%rip)    # 0xe27b68
jmp 0x1d9f36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9f26
leaq 0x191993(%rip), %rax    # 0x36b8b0
movq %rax, 0xc4dc44(%rip)    # 0xe27b68
jmp 0x1d9f34
leaq 0xbd873(%rip), %rax     # 0x2977a0
movq %rax, 0xc4dc34(%rip)    # 0xe27b68
jmp 0x1d9f36
jmp 0x1d9f38
movq 0xc4dc29(%rip), %rax    # 0xe27b68
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_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_16_pointer = parasail_sw_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d9fae
leaq 0x7a6f7b(%rip), %rax    # 0x980f20
movq %rax, 0xc4dbc4(%rip)    # 0xe27b70
jmp 0x1d9ff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d9fca
leaq 0x47a37f(%rip), %rax    # 0x654340
movq %rax, 0xc4dba8(%rip)    # 0xe27b70
jmp 0x1d9ff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9fe6
leaq 0x19aad3(%rip), %rax    # 0x374ab0
movq %rax, 0xc4db8c(%rip)    # 0xe27b70
jmp 0x1d9ff4
leaq 0xbd7b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4db7c(%rip)    # 0xe27b70
jmp 0x1d9ff6
jmp 0x1d9ff8
movq 0xc4db71(%rip), %rax    # 0xe27b70
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_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_8_pointer = parasail_sw_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1da06e
leaq 0x7b43cb(%rip), %rax    # 0x98e430
movq %rax, 0xc4db0c(%rip)    # 0xe27b78
jmp 0x1da0b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da08a
leaq 0x4849cf(%rip), %rax    # 0x65ea50
movq %rax, 0xc4daf0(%rip)    # 0xe27b78
jmp 0x1da0b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da0a6
leaq 0x1a48f3(%rip), %rax    # 0x37e990
movq %rax, 0xc4dad4(%rip)    # 0xe27b78
jmp 0x1da0b4
leaq 0xbd6f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4dac4(%rip)    # 0xe27b78
jmp 0x1da0b6
jmp 0x1da0b8
movq 0xc4dab9(%rip), %rax    # 0xe27b78
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_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_64_pointer = parasail_sw_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1da12e
leaq 0x74d50b(%rip), %rax    # 0x927630
movq %rax, 0xc4da54(%rip)    # 0xe27b80
jmp 0x1da178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da14a
leaq 0x4391cf(%rip), %rax    # 0x613310
movq %rax, 0xc4da38(%rip)    # 0xe27b80
jmp 0x1da176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da166
leaq 0x15bd23(%rip), %rax    # 0x335e80
movq %rax, 0xc4da1c(%rip)    # 0xe27b80
jmp 0x1da174
leaq 0xbd633(%rip), %rax     # 0x2977a0
movq %rax, 0xc4da0c(%rip)    # 0xe27b80
jmp 0x1da176
jmp 0x1da178
movq 0xc4da01(%rip), %rax    # 0xe27b80
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_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_32_pointer = parasail_sw_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1da1ee
leaq 0x75a54b(%rip), %rax    # 0x934730
movq %rax, 0xc4d99c(%rip)    # 0xe27b88
jmp 0x1da238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da20a
leaq 0x442baf(%rip), %rax    # 0x61cdb0
movq %rax, 0xc4d980(%rip)    # 0xe27b88
jmp 0x1da236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da226
leaq 0x165103(%rip), %rax    # 0x33f320
movq %rax, 0xc4d964(%rip)    # 0xe27b88
jmp 0x1da234
leaq 0xbd573(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d954(%rip)    # 0xe27b88
jmp 0x1da236
jmp 0x1da238
movq 0xc4d949(%rip), %rax    # 0xe27b88
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_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_16_pointer = parasail_sw_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1da2ae
leaq 0x76a86b(%rip), %rax    # 0x944b10
movq %rax, 0xc4d8e4(%rip)    # 0xe27b90
jmp 0x1da2f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da2ca
leaq 0x44dd4f(%rip), %rax    # 0x628010
movq %rax, 0xc4d8c8(%rip)    # 0xe27b90
jmp 0x1da2f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da2e6
leaq 0x16fbf3(%rip), %rax    # 0x349ed0
movq %rax, 0xc4d8ac(%rip)    # 0xe27b90
jmp 0x1da2f4
leaq 0xbd4b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d89c(%rip)    # 0xe27b90
jmp 0x1da2f6
jmp 0x1da2f8
movq 0xc4d891(%rip), %rax    # 0xe27b90
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_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_8_pointer = parasail_sw_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1da36e
leaq 0x780b4b(%rip), %rax    # 0x95aeb0
movq %rax, 0xc4d82c(%rip)    # 0xe27b98
jmp 0x1da3b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da38a
leaq 0x45ba7f(%rip), %rax    # 0x635e00
movq %rax, 0xc4d810(%rip)    # 0xe27b98
jmp 0x1da3b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da3a6
leaq 0x17d723(%rip), %rax    # 0x357ac0
movq %rax, 0xc4d7f4(%rip)    # 0xe27b98
jmp 0x1da3b4
leaq 0xbd3f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4d7e4(%rip)    # 0xe27b98
jmp 0x1da3b6
jmp 0x1da3b8
movq 0xc4d7d9(%rip), %rax    # 0xe27b98
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_64_dispatcher
parasail_result_t* parasail_sw_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_table_scan_64_pointer = parasail_sw_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1da42e
leaq 0x7bfddb(%rip), %rax    # 0x99a200
movq %rax, 0xc4d774(%rip)    # 0xe27ba0
jmp 0x1da478
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da44a
leaq 0x48bd1f(%rip), %rax    # 0x666160
movq %rax, 0xc4d758(%rip)    # 0xe27ba0
jmp 0x1da476
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da466
leaq 0x1add33(%rip), %rax    # 0x388190
movq %rax, 0xc4d73c(%rip)    # 0xe27ba0
jmp 0x1da474
leaq 0xbf293(%rip), %rax     # 0x299700
movq %rax, 0xc4d72c(%rip)    # 0xe27ba0
jmp 0x1da476
jmp 0x1da478
movq 0xc4d721(%rip), %rax    # 0xe27ba0
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_32_dispatcher
parasail_result_t* parasail_sw_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_table_scan_32_pointer = parasail_sw_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1da4ee
leaq 0x7c673b(%rip), %rax    # 0x9a0c20
movq %rax, 0xc4d6bc(%rip)    # 0xe27ba8
jmp 0x1da538
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1da50a
leaq 0x4911af(%rip), %rax    # 0x66b6b0
movq %rax, 0xc4d6a0(%rip)    # 0xe27ba8
jmp 0x1da536
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1da526
leaq 0x1b3463(%rip), %rax    # 0x38d980
movq %rax, 0xc4d684(%rip)    # 0xe27ba8
jmp 0x1da534
leaq 0xbf1d3(%rip), %rax     # 0x299700
movq %rax, 0xc4d674(%rip)    # 0xe27ba8
jmp 0x1da536
jmp 0x1da538
movq 0xc4d669(%rip), %rax    # 0xe27ba8
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)