LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_32_dispatcher
parasail_result_t* parasail_nw_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c3c6
leaq 0x2a1d80(%rip), %rax    # 0x4ae144
jmp 0x20c3f5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c3da
leaq 0x1b68a0(%rip), %rax    # 0x3c2c78
jmp 0x20c3f5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c3ee
leaq 0x8f178(%rip), %rax     # 0x29b564
jmp 0x20c3f5
leaq 0xa3ccf(%rip), %rax     # 0x2b00c4
movq %rax, 0x5cbe2c(%rip)    # 0x7d8228
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_16_dispatcher
parasail_result_t* parasail_nw_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c44f
leaq 0x2a3587(%rip), %rax    # 0x4af9d4
jmp 0x20c47e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c463
leaq 0x1b816f(%rip), %rax    # 0x3c45d0
jmp 0x20c47e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c477
leaq 0x8f0ef(%rip), %rax     # 0x29b564
jmp 0x20c47e
leaq 0xa5a3a(%rip), %rax     # 0x2b1eb8
movq %rax, 0x5cbdab(%rip)    # 0x7d8230
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_8_dispatcher
parasail_result_t* parasail_nw_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c4d8
leaq 0x2a58fa(%rip), %rax    # 0x4b1dd0
jmp 0x20c507
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c4ec
leaq 0x1b9d02(%rip), %rax    # 0x3c61ec
jmp 0x20c507
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c500
leaq 0x8f066(%rip), %rax     # 0x29b564
jmp 0x20c507
leaq 0xa79ad(%rip), %rax     # 0x2b3eb4
movq %rax, 0x5cbd2a(%rip)    # 0x7d8238
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_64_dispatcher
parasail_result_t* parasail_nw_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c561
leaq 0x2b1ec9(%rip), %rax    # 0x4be428
jmp 0x20c590
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c575
leaq 0x1c3289(%rip), %rax    # 0x3cf7fc
jmp 0x20c590
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c589
leaq 0x8e255(%rip), %rax     # 0x29a7dc
jmp 0x20c590
leaq 0xb2e10(%rip), %rax     # 0x2bf3a0
movq %rax, 0x5cbca9(%rip)    # 0x7d8240
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_32_dispatcher
parasail_result_t* parasail_nw_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c5ea
leaq 0x2b3478(%rip), %rax    # 0x4bfa60
jmp 0x20c619
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c5fe
leaq 0x1c49b0(%rip), %rax    # 0x3d0fac
jmp 0x20c619
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c612
leaq 0x8e1cc(%rip), %rax     # 0x29a7dc
jmp 0x20c619
leaq 0xb4cd3(%rip), %rax     # 0x2c12ec
movq %rax, 0x5cbc28(%rip)    # 0x7d8248
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_16_dispatcher
parasail_result_t* parasail_nw_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_16_pointer = parasail_nw_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c673
leaq 0x2b49cf(%rip), %rax    # 0x4c1040
jmp 0x20c6a2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c687
leaq 0x1c5fc7(%rip), %rax    # 0x3d264c
jmp 0x20c6a2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c69b
leaq 0x8e143(%rip), %rax     # 0x29a7dc
jmp 0x20c6a2
leaq 0xb66e6(%rip), %rax     # 0x2c2d88
movq %rax, 0x5cbba7(%rip)    # 0x7d8250
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_8_dispatcher
parasail_result_t* parasail_nw_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_8_pointer = parasail_nw_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c6fc
leaq 0x2b6aaa(%rip), %rax    # 0x4c31a4
jmp 0x20c72b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c710
leaq 0x1c791e(%rip), %rax    # 0x3d402c
jmp 0x20c72b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c724
leaq 0x8e0ba(%rip), %rax     # 0x29a7dc
jmp 0x20c72b
leaq 0xb83a1(%rip), %rax     # 0x2c4acc
movq %rax, 0x5cbb26(%rip)    # 0x7d8258
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_64_dispatcher
parasail_result_t* parasail_nw_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_64_pointer = parasail_nw_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c785
leaq 0x2a8851(%rip), %rax    # 0x4b4fd4
jmp 0x20c7b4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c799
leaq 0x1bba79(%rip), %rax    # 0x3c8210
jmp 0x20c7b4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c7ad
leaq 0x8e031(%rip), %rax     # 0x29a7dc
jmp 0x20c7b4
leaq 0xaa200(%rip), %rax     # 0x2b69b4
movq %rax, 0x5cbaa5(%rip)    # 0x7d8260
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_32_dispatcher
parasail_result_t* parasail_nw_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c80e
leaq 0x2aa380(%rip), %rax    # 0x4b6b8c
jmp 0x20c83d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c822
leaq 0x1bd1ec(%rip), %rax    # 0x3c9a0c
jmp 0x20c83d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c836
leaq 0x8dfa8(%rip), %rax     # 0x29a7dc
jmp 0x20c83d
leaq 0xac163(%rip), %rax     # 0x2b89a0
movq %rax, 0x5cba24(%rip)    # 0x7d8268
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_16_dispatcher
parasail_result_t* parasail_nw_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c897
leaq 0x2ac00b(%rip), %rax    # 0x4b88a0
jmp 0x20c8c6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c8ab
leaq 0x1be9db(%rip), %rax    # 0x3cb284
jmp 0x20c8c6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c8bf
leaq 0x8df1f(%rip), %rax     # 0x29a7dc
jmp 0x20c8c6
leaq 0xadc02(%rip), %rax     # 0x2ba4c8
movq %rax, 0x5cb9a3(%rip)    # 0x7d8270
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_8_dispatcher
parasail_result_t* parasail_nw_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c920
leaq 0x2ae666(%rip), %rax    # 0x4baf84
jmp 0x20c94f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c934
leaq 0x1c067a(%rip), %rax    # 0x3ccfac
jmp 0x20c94f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c948
leaq 0x8de96(%rip), %rax     # 0x29a7dc
jmp 0x20c94f
leaq 0xafafd(%rip), %rax     # 0x2bc44c
movq %rax, 0x5cb922(%rip)    # 0x7d8278
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_64_dispatcher
parasail_result_t* parasail_nw_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c9a9
leaq 0x2b9731(%rip), %rax    # 0x4c60d8
jmp 0x20c9d8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c9bd
leaq 0x1c9b09(%rip), %rax    # 0x3d64c4
jmp 0x20c9d8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c9d1
leaq 0x8eb95(%rip), %rax     # 0x29b564
jmp 0x20c9d8
leaq 0xba7e0(%rip), %rax     # 0x2c71b8
movq %rax, 0x5cb8a1(%rip)    # 0x7d8280
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_32_dispatcher
parasail_result_t* parasail_nw_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20ca32
leaq 0x2bc66c(%rip), %rax    # 0x4c909c
jmp 0x20ca61
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20ca46
leaq 0x1ccb3c(%rip), %rax    # 0x3d9580
jmp 0x20ca61
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20ca5a
leaq 0x8eb0c(%rip), %rax     # 0x29b564
jmp 0x20ca61
leaq 0xbe71f(%rip), %rax     # 0x2cb180
movq %rax, 0x5cb820(%rip)    # 0x7d8288
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_16_dispatcher
parasail_result_t* parasail_nw_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cabb
leaq 0x2bf507(%rip), %rax    # 0x4cbfc0
jmp 0x20caea
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20cacf
leaq 0x1cfafb(%rip), %rax    # 0x3dc5c8
jmp 0x20caea
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cae3
leaq 0x8ea83(%rip), %rax     # 0x29b564
jmp 0x20caea
leaq 0xc1d16(%rip), %rax     # 0x2ce800
movq %rax, 0x5cb79f(%rip)    # 0x7d8290
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_8_dispatcher
parasail_result_t* parasail_nw_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cb44
leaq 0x2c2c6a(%rip), %rax    # 0x4cf7ac
jmp 0x20cb73
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20cb58
leaq 0x1d2f22(%rip), %rax    # 0x3dfa78
jmp 0x20cb73
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cb6c
leaq 0x8e9fa(%rip), %rax     # 0x29b564
jmp 0x20cb73
leaq 0xc57d5(%rip), %rax     # 0x2d2348
movq %rax, 0x5cb71e(%rip)    # 0x7d8298
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_64_dispatcher
parasail_result_t* parasail_nw_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cbcd
leaq 0x2d731d(%rip), %rax    # 0x4e3ee8
jmp 0x20cbfc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20cbe1
leaq 0x1e49d1(%rip), %rax    # 0x3f15b0
jmp 0x20cbfc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cbf5
leaq 0x8dbe9(%rip), %rax     # 0x29a7dc
jmp 0x20cbfc
leaq 0xda580(%rip), %rax     # 0x2e717c
movq %rax, 0x5cb69d(%rip)    # 0x7d82a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_32_dispatcher
parasail_result_t* parasail_nw_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cc56
leaq 0x2da048(%rip), %rax    # 0x4e6c9c
jmp 0x20cc85
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20cc6a
leaq 0x1e780c(%rip), %rax    # 0x3f4474
jmp 0x20cc85
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cc7e
leaq 0x8db60(%rip), %rax     # 0x29a7dc
jmp 0x20cc85
leaq 0xde43b(%rip), %rax     # 0x2eb0c0
movq %rax, 0x5cb61c(%rip)    # 0x7d82a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_16_dispatcher
parasail_result_t* parasail_nw_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20ccdf
leaq 0x2dcca7(%rip), %rax    # 0x4e9984
jmp 0x20cd0e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20ccf3
leaq 0x1ea5bb(%rip), %rax    # 0x3f72ac
jmp 0x20cd0e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cd07
leaq 0x8dad7(%rip), %rax     # 0x29a7dc
jmp 0x20cd0e
leaq 0xe1972(%rip), %rax     # 0x2ee680
movq %rax, 0x5cb59b(%rip)    # 0x7d82b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_8_dispatcher
parasail_result_t* parasail_nw_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cd68
leaq 0x2e0482(%rip), %rax    # 0x4ed1e8
jmp 0x20cd97
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20cd7c
leaq 0x1ed7b6(%rip), %rax    # 0x3fa530
jmp 0x20cd97
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cd90
leaq 0x8da4e(%rip), %rax     # 0x29a7dc
jmp 0x20cd97
leaq 0xe4ff5(%rip), %rax     # 0x2f1d8c
movq %rax, 0x5cb51a(%rip)    # 0x7d82b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_64_dispatcher
parasail_result_t* parasail_nw_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cdf1
leaq 0x2c6ca9(%rip), %rax    # 0x4d3a98
jmp 0x20ce20
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20ce05
leaq 0x1d6505(%rip), %rax    # 0x3e3308
jmp 0x20ce20
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20ce19
leaq 0x8d9c5(%rip), %rax     # 0x29a7dc
jmp 0x20ce20
leaq 0xc9c0c(%rip), %rax     # 0x2d6a2c
movq %rax, 0x5cb499(%rip)    # 0x7d82c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_32_dispatcher
parasail_result_t* parasail_nw_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20ce7a
leaq 0x2ca0e0(%rip), %rax    # 0x4d6f58
jmp 0x20cea9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20ce8e
leaq 0x1d9608(%rip), %rax    # 0x3e6494
jmp 0x20cea9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cea2
leaq 0x8d93c(%rip), %rax     # 0x29a7dc
jmp 0x20cea9
leaq 0xcdb27(%rip), %rax     # 0x2da9d0
movq %rax, 0x5cb418(%rip)    # 0x7d82c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_16_dispatcher
parasail_result_t* parasail_nw_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cf03
leaq 0x2cd67b(%rip), %rax    # 0x4da57c
jmp 0x20cf32
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20cf17
leaq 0x1dc71f(%rip), %rax    # 0x3e9634
jmp 0x20cf32
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cf2b
leaq 0x8d8b3(%rip), %rax     # 0x29a7dc
jmp 0x20cf32
leaq 0xd1196(%rip), %rax     # 0x2de0c8
movq %rax, 0x5cb397(%rip)    # 0x7d82d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_diag_8_dispatcher
parasail_result_t* parasail_nw_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20cf8c
leaq 0x2d196e(%rip), %rax    # 0x4de8f8
jmp 0x20cfbb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20cfa0
leaq 0x1dff62(%rip), %rax    # 0x3ecf00
jmp 0x20cfbb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20cfb4
leaq 0x8d82a(%rip), %rax     # 0x29a7dc
jmp 0x20cfbb
leaq 0xd4c1d(%rip), %rax     # 0x2e1bd8
movq %rax, 0x5cb316(%rip)    # 0x7d82d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax