LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_16_dispatcher
parasail_result_t* parasail_nw_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af67f
leaq 0x35c8e3(%rip), %rax    # 0x50bf60
jmp 0x1af6ae
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af693
leaq 0x252e83(%rip), %rax    # 0x402514
jmp 0x1af6ae
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af6a7
leaq 0x8c793(%rip), %rax     # 0x23be38
jmp 0x1af6ae
leaq 0x1572ce(%rip), %rax    # 0x30697c
movq %rax, 0x58bd1b(%rip)    # 0x73b3d0
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_8_dispatcher
parasail_result_t* parasail_nw_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af708
leaq 0x35e8ae(%rip), %rax    # 0x50dfb4
jmp 0x1af737
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af71c
leaq 0x254ae2(%rip), %rax    # 0x4041fc
jmp 0x1af737
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af730
leaq 0x8c70a(%rip), %rax     # 0x23be38
jmp 0x1af737
leaq 0x158fb9(%rip), %rax    # 0x3086f0
movq %rax, 0x58bc9a(%rip)    # 0x73b3d8
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_64_dispatcher
parasail_result_t* parasail_nw_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af791
leaq 0x348fbd(%rip), %rax    # 0x4f874c
jmp 0x1af7c0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af7a5
leaq 0x244989(%rip), %rax    # 0x3f412c
jmp 0x1af7c0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af7b9
leaq 0x8c681(%rip), %rax     # 0x23be38
jmp 0x1af7c0
leaq 0x146c30(%rip), %rax    # 0x2f63f0
movq %rax, 0x58bc19(%rip)    # 0x73b3e0
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_32_dispatcher
parasail_result_t* parasail_nw_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af81a
leaq 0x34b488(%rip), %rax    # 0x4faca0
jmp 0x1af849
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af82e
leaq 0x24685c(%rip), %rax    # 0x3f6088
jmp 0x1af849
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af842
leaq 0x8c5f8(%rip), %rax     # 0x23be38
jmp 0x1af849
leaq 0x14928b(%rip), %rax    # 0x2f8ad4
movq %rax, 0x58bb98(%rip)    # 0x73b3e8
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_16_dispatcher
parasail_result_t* parasail_nw_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af8a3
leaq 0x34dd53(%rip), %rax    # 0x4fd5f4
jmp 0x1af8d2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af8b7
leaq 0x2485df(%rip), %rax    # 0x3f7e94
jmp 0x1af8d2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af8cb
leaq 0x8c56f(%rip), %rax     # 0x23be38
jmp 0x1af8d2
leaq 0x14b352(%rip), %rax    # 0x2fac24
movq %rax, 0x58bb17(%rip)    # 0x73b3f0
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_diag_8_dispatcher
parasail_result_t* parasail_nw_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_rowcol_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af92c
leaq 0x351d9e(%rip), %rax    # 0x5016c8
jmp 0x1af95b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af940
leaq 0x24aefe(%rip), %rax    # 0x3fa83c
jmp 0x1af95b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af954
leaq 0x8c4e6(%rip), %rax     # 0x23be38
jmp 0x1af95b
leaq 0x14dfb1(%rip), %rax    # 0x2fd90c
movq %rax, 0x58ba96(%rip)    # 0x73b3f8
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af9b5
leaq 0x360ccd(%rip), %rax    # 0x510680
jmp 0x1af9e4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af9c9
leaq 0x256fe5(%rip), %rax    # 0x4069ac
jmp 0x1af9e4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af9dd
leaq 0x8d421(%rip), %rax     # 0x23cdfc
jmp 0x1af9e4
leaq 0x15b030(%rip), %rax    # 0x30aa14
movq %rax, 0x58ba15(%rip)    # 0x73b400
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afa3e
leaq 0x3656e4(%rip), %rax    # 0x515120
jmp 0x1afa6d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afa52
leaq 0x25b428(%rip), %rax    # 0x40ae78
jmp 0x1afa6d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afa66
leaq 0x8d398(%rip), %rax     # 0x23cdfc
jmp 0x1afa6d
leaq 0x1602bf(%rip), %rax    # 0x30fd2c
movq %rax, 0x58b994(%rip)    # 0x73b408
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afac7
leaq 0x3691bb(%rip), %rax    # 0x518c80
jmp 0x1afaf6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afadb
leaq 0x25ed6f(%rip), %rax    # 0x40e848
jmp 0x1afaf6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afaef
leaq 0x8d30f(%rip), %rax     # 0x23cdfc
jmp 0x1afaf6
leaq 0x16426e(%rip), %rax    # 0x313d64
movq %rax, 0x58b913(%rip)    # 0x73b410
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afb50
leaq 0x36cece(%rip), %rax    # 0x51ca1c
jmp 0x1afb7f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afb64
leaq 0x26288a(%rip), %rax    # 0x4123ec
jmp 0x1afb7f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afb78
leaq 0x8d286(%rip), %rax     # 0x23cdfc
jmp 0x1afb7f
leaq 0x168105(%rip), %rax    # 0x317c84
movq %rax, 0x58b892(%rip)    # 0x73b418
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afbd9
leaq 0x3868d5(%rip), %rax    # 0x5364ac
jmp 0x1afc08
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afbed
leaq 0x277fd9(%rip), %rax    # 0x427bc4
jmp 0x1afc08
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afc01
leaq 0x8c239(%rip), %rax     # 0x23be38
jmp 0x1afc08
leaq 0x180210(%rip), %rax    # 0x32fe18
movq %rax, 0x58b811(%rip)    # 0x73b420
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afc62
leaq 0x38aa28(%rip), %rax    # 0x53a688
jmp 0x1afc91
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afc76
leaq 0x27befc(%rip), %rax    # 0x42bb70
jmp 0x1afc91
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afc8a
leaq 0x8c1b0(%rip), %rax     # 0x23be38
jmp 0x1afc91
leaq 0x184f27(%rip), %rax    # 0x334bb8
movq %rax, 0x58b790(%rip)    # 0x73b428
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afceb
leaq 0x38e163(%rip), %rax    # 0x53de4c
jmp 0x1afd1a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afcff
leaq 0x27f52b(%rip), %rax    # 0x42f228
jmp 0x1afd1a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afd13
leaq 0x8c127(%rip), %rax     # 0x23be38
jmp 0x1afd1a
leaq 0x188c76(%rip), %rax    # 0x338990
movq %rax, 0x58b70f(%rip)    # 0x73b430
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afd74
leaq 0x391cfa(%rip), %rax    # 0x541a6c
jmp 0x1afda3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afd88
leaq 0x282e8e(%rip), %rax    # 0x432c14
jmp 0x1afda3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afd9c
leaq 0x8c09e(%rip), %rax     # 0x23be38
jmp 0x1afda3
leaq 0x18c831(%rip), %rax    # 0x33c5d4
movq %rax, 0x58b68e(%rip)    # 0x73b438
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afdfd
leaq 0x370e81(%rip), %rax    # 0x520c7c
jmp 0x1afe2c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afe11
leaq 0x2663c1(%rip), %rax    # 0x4161d0
jmp 0x1afe2c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afe25
leaq 0x8c015(%rip), %rax     # 0x23be38
jmp 0x1afe2c
leaq 0x16c2dc(%rip), %rax    # 0x31c108
movq %rax, 0x58b60d(%rip)    # 0x73b440
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1afe86
leaq 0x374ef0(%rip), %rax    # 0x524d74
jmp 0x1afeb5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1afe9a
leaq 0x26a264(%rip), %rax    # 0x41a0fc
jmp 0x1afeb5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1afeae
leaq 0x8bf8c(%rip), %rax     # 0x23be38
jmp 0x1afeb5
leaq 0x170d13(%rip), %rax    # 0x320bc8
movq %rax, 0x58b58c(%rip)    # 0x73b448
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1aff0f
leaq 0x379037(%rip), %rax    # 0x528f44
jmp 0x1aff3e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aff23
leaq 0x26dc53(%rip), %rax    # 0x41db74
jmp 0x1aff3e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aff37
leaq 0x8bf03(%rip), %rax     # 0x23be38
jmp 0x1aff3e
leaq 0x174caa(%rip), %rax    # 0x324be8
movq %rax, 0x58b50b(%rip)    # 0x73b450
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_rowcol_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1aff98
leaq 0x37e956(%rip), %rax    # 0x52e8ec
jmp 0x1affc7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1affac
leaq 0x2720e2(%rip), %rax    # 0x42208c
jmp 0x1affc7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1affc0
leaq 0x8be7a(%rip), %rax     # 0x23be38
jmp 0x1affc7
leaq 0x179519(%rip), %rax    # 0x3294e0
movq %rax, 0x58b48a(%rip)    # 0x73b458
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_64_dispatcher
parasail_result_t* parasail_nw_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_64_pointer = parasail_nw_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_trace_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0021
leaq 0x395b69(%rip), %rax    # 0x545b88
jmp 0x1b0050
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0035
leaq 0x2867f5(%rip), %rax    # 0x436828
jmp 0x1b0050
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b0049
leaq 0x8cdb5(%rip), %rax     # 0x23cdfc
jmp 0x1b0050
leaq 0x1907b0(%rip), %rax    # 0x340800
movq %rax, 0x58b409(%rip)    # 0x73b460
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_32_dispatcher
parasail_result_t* parasail_nw_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_32_pointer = parasail_nw_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_trace_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_trace_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b00aa
leaq 0x397f84(%rip), %rax    # 0x54802c
jmp 0x1b00d9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b00be
leaq 0x288b3c(%rip), %rax    # 0x438bf8
jmp 0x1b00d9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b00d2
leaq 0x8cd2c(%rip), %rax     # 0x23cdfc
jmp 0x1b00d9
leaq 0x19339b(%rip), %rax    # 0x343474
movq %rax, 0x58b388(%rip)    # 0x73b468
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_16_dispatcher
parasail_result_t* parasail_nw_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_16_pointer = parasail_nw_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_trace_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_trace_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0133
leaq 0x399cb7(%rip), %rax    # 0x549de8
jmp 0x1b0162
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0147
leaq 0x28a877(%rip), %rax    # 0x43a9bc
jmp 0x1b0162
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b015b
leaq 0x8cca3(%rip), %rax     # 0x23cdfc
jmp 0x1b0162
leaq 0x195412(%rip), %rax    # 0x345574
movq %rax, 0x58b307(%rip)    # 0x73b470
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_8_dispatcher
parasail_result_t* parasail_nw_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_8_pointer = parasail_nw_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_trace_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_trace_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b01bc
leaq 0x39ba3e(%rip), %rax    # 0x54bbf8
jmp 0x1b01eb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b01d0
leaq 0x28c6c6(%rip), %rax    # 0x43c894
jmp 0x1b01eb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b01e4
leaq 0x8cc1a(%rip), %rax     # 0x23cdfc
jmp 0x1b01eb
leaq 0x1972ed(%rip), %rax    # 0x3474d8
movq %rax, 0x58b286(%rip)    # 0x73b478
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