LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_8_dispatcher
parasail_result_t* parasail_nw_trace_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_trace_striped_8_pointer = parasail_nw_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_trace_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_trace_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 0x594f9c
testl %eax, %eax
je 0x20d78c
leaq 0x385582(%rip), %rax    # 0x592d0c
jmp 0x20d7bb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d7a0
leaq 0x27541e(%rip), %rax    # 0x482bbc
jmp 0x20d7bb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d7b4
leaq 0x8ba32(%rip), %rax     # 0x2991e4
jmp 0x20d7bb
leaq 0x191f21(%rip), %rax    # 0x39f6dc
movq %rax, 0x594cd6(%rip)    # 0x7a2498
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_diag_64_dispatcher
parasail_result_t* parasail_nw_trace_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_trace_diag_64_pointer = parasail_nw_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_trace_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_trace_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 0x594f9c
testl %eax, %eax
je 0x20d815
leaq 0x36eed1(%rip), %rax    # 0x57c6e4
jmp 0x20d844
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d829
leaq 0x2642a1(%rip), %rax    # 0x471ac8
jmp 0x20d844
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d83d
leaq 0x8b9a9(%rip), %rax     # 0x2991e4
jmp 0x20d844
leaq 0x17f53c(%rip), %rax    # 0x38cd80
movq %rax, 0x594c55(%rip)    # 0x7a24a0
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_diag_32_dispatcher
parasail_result_t* parasail_nw_trace_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_trace_diag_32_pointer = parasail_nw_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_trace_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_trace_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 0x594f9c
testl %eax, %eax
je 0x20d89e
leaq 0x3718dc(%rip), %rax    # 0x57f178
jmp 0x20d8cd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d8b2
leaq 0x2662b4(%rip), %rax    # 0x473b64
jmp 0x20d8cd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d8c6
leaq 0x8b920(%rip), %rax     # 0x2991e4
jmp 0x20d8cd
leaq 0x181b3f(%rip), %rax    # 0x38f40c
movq %rax, 0x594bd4(%rip)    # 0x7a24a8
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_diag_16_dispatcher
parasail_result_t* parasail_nw_trace_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_trace_diag_16_pointer = parasail_nw_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_trace_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_trace_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 0x594f9c
testl %eax, %eax
je 0x20d927
leaq 0x374177(%rip), %rax    # 0x581a9c
jmp 0x20d956
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d93b
leaq 0x26814b(%rip), %rax    # 0x475a84
jmp 0x20d956
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d94f
leaq 0x8b897(%rip), %rax     # 0x2991e4
jmp 0x20d956
leaq 0x183c1a(%rip), %rax    # 0x391570
movq %rax, 0x594b53(%rip)    # 0x7a24b0
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_diag_8_dispatcher
parasail_result_t* parasail_nw_trace_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_trace_diag_8_pointer = parasail_nw_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_trace_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_trace_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 0x594f9c
testl %eax, %eax
je 0x20d9b0
leaq 0x377cea(%rip), %rax    # 0x585698
jmp 0x20d9df
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20d9c4
leaq 0x26a8d6(%rip), %rax    # 0x478298
jmp 0x20d9df
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20d9d8
leaq 0x8b80e(%rip), %rax     # 0x2991e4
jmp 0x20d9df
leaq 0x186595(%rip), %rax    # 0x393f74
movq %rax, 0x594ad2(%rip)    # 0x7a24b8
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20da32
leaq 0x277356(%rip), %rax    # 0x484d86
jmp 0x20da58
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20da46
leaq 0x1942c6(%rip), %rax    # 0x3a1d0a
jmp 0x20da58
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20da77
leaq 0x9d422(%rip), %rax     # 0x2aae7a
movq %rax, 0x594a61(%rip)    # 0x7a24c0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20daac
leaq 0x2798c4(%rip), %rax    # 0x48736e
jmp 0x20dad2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20dac0
leaq 0x195dc4(%rip), %rax    # 0x3a3882
jmp 0x20dad2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20daf1
leaq 0x9efcc(%rip), %rax     # 0x2aca9e
movq %rax, 0x5949ef(%rip)    # 0x7a24c8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20db26
leaq 0x27aeda(%rip), %rax    # 0x4889fe
jmp 0x20db4c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20db3a
leaq 0x19737a(%rip), %rax    # 0x3a4eb2
jmp 0x20db4c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20db6b
leaq 0xa0892(%rip), %rax     # 0x2ae3de
movq %rax, 0x59497d(%rip)    # 0x7a24d0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20dba0
leaq 0x27c54c(%rip), %rax    # 0x48a0ea
jmp 0x20dbc6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20dbb4
leaq 0x198a00(%rip), %rax    # 0x3a65b2
jmp 0x20dbc6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20dbe5
leaq 0xa1f14(%rip), %rax     # 0x2afada
movq %rax, 0x59490b(%rip)    # 0x7a24d8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20dc1a
leaq 0x2882ca(%rip), %rax    # 0x495ee2
jmp 0x20dc40
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20dc2e
leaq 0x1a1c4a(%rip), %rax    # 0x3af876
jmp 0x20dc40
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20dc5f
leaq 0xac242(%rip), %rax     # 0x2b9e82
movq %rax, 0x594899(%rip)    # 0x7a24e0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20dc94
leaq 0x28a398(%rip), %rax    # 0x49802a
jmp 0x20dcba
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20dca8
leaq 0x1a3600(%rip), %rax    # 0x3b12a6
jmp 0x20dcba
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20dcd9
leaq 0xadcbc(%rip), %rax     # 0x2bb976
movq %rax, 0x594827(%rip)    # 0x7a24e8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20dd0e
leaq 0x28b7b6(%rip), %rax    # 0x4994c2
jmp 0x20dd34
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20dd22
leaq 0x1a4a1e(%rip), %rax    # 0x3b273e
jmp 0x20dd34
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20dd53
leaq 0xaf2e2(%rip), %rax     # 0x2bd016
movq %rax, 0x5947b5(%rip)    # 0x7a24f0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20dd88
leaq 0x28cc40(%rip), %rax    # 0x49a9c6
jmp 0x20ddae
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20dd9c
leaq 0x1a5e94(%rip), %rax    # 0x3b3c2e
jmp 0x20ddae
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20ddcd
leaq 0xb0734(%rip), %rax     # 0x2be4e2
movq %rax, 0x594743(%rip)    # 0x7a24f8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20de02
leaq 0x28e0b6(%rip), %rax    # 0x49beb6
jmp 0x20de28
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20de16
leaq 0x1a7a06(%rip), %rax    # 0x3b581a
jmp 0x20de28
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20de47
leaq 0xb1ede(%rip), %rax     # 0x2bfd06
movq %rax, 0x5946d1(%rip)    # 0x7a2500
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_stats_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20de7c
leaq 0x2920cc(%rip), %rax    # 0x49ff46
jmp 0x20dea2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20de90
leaq 0x1aaf5c(%rip), %rax    # 0x3b8dea
jmp 0x20dea2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20dec1
leaq 0xb5a6c(%rip), %rax     # 0x2c390e
movq %rax, 0x59465f(%rip)    # 0x7a2508
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_stats_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20def6
leaq 0x294e76(%rip), %rax    # 0x4a2d6a
jmp 0x20df1c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20df0a
leaq 0x1adcb6(%rip), %rax    # 0x3bbbbe
jmp 0x20df1c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20df3b
leaq 0xb8e4e(%rip), %rax     # 0x2c6d6a
movq %rax, 0x5945ed(%rip)    # 0x7a2510
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_stats_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20df70
leaq 0x297cb8(%rip), %rax    # 0x4a5c26
jmp 0x20df96
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20df84
leaq 0x1b0ae0(%rip), %rax    # 0x3bea62
jmp 0x20df96
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20dfb5
leaq 0xbbfc8(%rip), %rax     # 0x2c9f5e
movq %rax, 0x59457b(%rip)    # 0x7a2518
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20dfea
leaq 0x2ac092(%rip), %rax    # 0x4ba07a
jmp 0x20e010
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20dffe
leaq 0x1c1f9e(%rip), %rax    # 0x3cff9a
jmp 0x20e010
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20e02f
leaq 0xcf66e(%rip), %rax     # 0x2dd67e
movq %rax, 0x594509(%rip)    # 0x7a2520
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_stats_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20e064
leaq 0x2afaf0(%rip), %rax    # 0x4bdb52
jmp 0x20e08a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20e078
leaq 0x1c5388(%rip), %rax    # 0x3d33fe
jmp 0x20e08a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20e0a9
leaq 0xd3028(%rip), %rax     # 0x2e10b2
movq %rax, 0x594497(%rip)    # 0x7a2528
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_stats_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20e0de
leaq 0x2b257e(%rip), %rax    # 0x4c065a
jmp 0x20e104
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20e0f2
leaq 0x1c7e0e(%rip), %rax    # 0x3d5efe
jmp 0x20e104
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20e123
leaq 0xd614e(%rip), %rax     # 0x2e4252
movq %rax, 0x594425(%rip)    # 0x7a2530
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_stats_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_striped_profile_8_pointer = parasail_nw_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_profile_8_pointer = parasail_nw_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_profile_8_pointer = parasail_nw_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_profile_8_pointer = parasail_nw_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_profile_8_pointer = parasail_nw_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20e158
leaq 0x2b5154(%rip), %rax    # 0x4c32aa
jmp 0x20e17e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20e16c
leaq 0x1caab4(%rip), %rax    # 0x3d8c1e
jmp 0x20e17e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20e19d
leaq 0xd9014(%rip), %rax     # 0x2e7192
movq %rax, 0x5943b3(%rip)    # 0x7a2538
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_table_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_profile_64_pointer = parasail_nw_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_profile_64_pointer = parasail_nw_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_profile_64_pointer = parasail_nw_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_profile_64_pointer = parasail_nw_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_profile_64_pointer = parasail_nw_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20e1d2
leaq 0x2b8dde(%rip), %rax    # 0x4c6fae
jmp 0x20e1f8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20e1e6
leaq 0x1cd70a(%rip), %rax    # 0x3db8ee
jmp 0x20e1f8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20e217
leaq 0xdd2ea(%rip), %rax     # 0x2eb4e2
movq %rax, 0x594341(%rip)    # 0x7a2540
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_table_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_profile_32_pointer = parasail_nw_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_profile_32_pointer = parasail_nw_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_profile_32_pointer = parasail_nw_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_profile_32_pointer = parasail_nw_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_profile_32_pointer = parasail_nw_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20e24c
leaq 0x2bb664(%rip), %rax    # 0x4c98ae
jmp 0x20e272
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20e260
leaq 0x1cf3a0(%rip), %rax    # 0x3dd5fe
jmp 0x20e272
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20e291
leaq 0xdf024(%rip), %rax     # 0x2ed296
movq %rax, 0x5942cf(%rip)    # 0x7a2548
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq