LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_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 0x5c8fdb
testl %eax, %eax
je 0x20f380
leaq 0x2b3ed0(%rip), %rax    # 0x4c324e
jmp 0x20f3a6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f394
leaq 0x1c4d44(%rip), %rax    # 0x3d40d6
jmp 0x20f3a6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f3c5
leaq 0xb57d0(%rip), %rax     # 0x2c4b76
movq %rax, 0x5c914b(%rip)    # 0x7d84f8
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f3fa
leaq 0x2b6d96(%rip), %rax    # 0x4c618e
jmp 0x20f420
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f40e
leaq 0x1c716e(%rip), %rax    # 0x3d657a
jmp 0x20f420
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f43f
leaq 0xb7e4e(%rip), %rax     # 0x2c726e
movq %rax, 0x5c90d9(%rip)    # 0x7d8500
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f474
leaq 0x2b9ce0(%rip), %rax    # 0x4c9152
jmp 0x20f49a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f488
leaq 0x1ca1b0(%rip), %rax    # 0x3d9636
jmp 0x20f49a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f4b9
leaq 0xbbd9c(%rip), %rax     # 0x2cb236
movq %rax, 0x5c9067(%rip)    # 0x7d8508
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f4ee
leaq 0x2bcb8a(%rip), %rax    # 0x4cc076
jmp 0x20f514
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f502
leaq 0x1cd17e(%rip), %rax    # 0x3dc67e
jmp 0x20f514
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f533
leaq 0xbf3a2(%rip), %rax     # 0x2ce8b6
movq %rax, 0x5c8ff5(%rip)    # 0x7d8510
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f568
leaq 0x2c02fc(%rip), %rax    # 0x4cf862
jmp 0x20f58e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f57c
leaq 0x1d05b4(%rip), %rax    # 0x3dfb2e
jmp 0x20f58e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f5ad
leaq 0xc2e70(%rip), %rax     # 0x2d23fe
movq %rax, 0x5c8f83(%rip)    # 0x7d8518
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f5e2
leaq 0x2d49be(%rip), %rax    # 0x4e3f9e
jmp 0x20f608
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f5f6
leaq 0x1e2072(%rip), %rax    # 0x3f1666
jmp 0x20f608
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f627
leaq 0xd7c2a(%rip), %rax     # 0x2e7232
movq %rax, 0x5c8f11(%rip)    # 0x7d8520
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f65c
leaq 0x2d76f8(%rip), %rax    # 0x4e6d52
jmp 0x20f682
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f670
leaq 0x1e4ebc(%rip), %rax    # 0x3f452a
jmp 0x20f682
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f6a1
leaq 0xdbaf4(%rip), %rax     # 0x2eb176
movq %rax, 0x5c8e9f(%rip)    # 0x7d8528
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f6d6
leaq 0x2da366(%rip), %rax    # 0x4e9a3a
jmp 0x20f6fc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f6ea
leaq 0x1e7c7a(%rip), %rax    # 0x3f7362
jmp 0x20f6fc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f71b
leaq 0xdf03a(%rip), %rax     # 0x2ee736
movq %rax, 0x5c8e2d(%rip)    # 0x7d8530
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f750
leaq 0x2ddb50(%rip), %rax    # 0x4ed29e
jmp 0x20f776
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f764
leaq 0x1eae84(%rip), %rax    # 0x3fa5e6
jmp 0x20f776
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f795
leaq 0xe26cc(%rip), %rax     # 0x2f1e42
movq %rax, 0x5c8dbb(%rip)    # 0x7d8538
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f7ca
leaq 0x2e343e(%rip), %rax    # 0x4f2c06
jmp 0x20f7f0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f7de
leaq 0x1ee3de(%rip), %rax    # 0x3fdbba
jmp 0x20f7f0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f80f
leaq 0xe7a66(%rip), %rax     # 0x2f7256
movq %rax, 0x5c8d49(%rip)    # 0x7d8540
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20f844
leaq 0x2e4f1c(%rip), %rax    # 0x4f475e
jmp 0x20f86a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f858
leaq 0x1efe30(%rip), %rax    # 0x3ff686
jmp 0x20f86a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f889
leaq 0xe9b90(%rip), %rax     # 0x2f93fa
movq %rax, 0x5c8cd7(%rip)    # 0x7d8548
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_table_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_table_scan_profile_16_pointer = parasail_nw_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_profile_16_pointer = parasail_nw_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_profile_16_pointer = parasail_nw_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_profile_16_pointer = parasail_nw_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_profile_16_pointer = parasail_nw_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_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 0x5c8fdb
testl %eax, %eax
je 0x20f8be
leaq 0x2e6ba6(%rip), %rax    # 0x4f6462
jmp 0x20f8e4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f8d2
leaq 0x1f193a(%rip), %rax    # 0x40120a
jmp 0x20f8e4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f903
leaq 0xebb0e(%rip), %rax     # 0x2fb3f2
movq %rax, 0x5c8c65(%rip)    # 0x7d8550
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_table_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_table_scan_profile_8_pointer = parasail_nw_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_profile_8_pointer = parasail_nw_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_profile_8_pointer = parasail_nw_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_profile_8_pointer = parasail_nw_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_profile_8_pointer = parasail_nw_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_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 0x5c8fdb
testl %eax, %eax
je 0x20f938
leaq 0x2e9800(%rip), %rax    # 0x4f9136
jmp 0x20f95e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f94c
leaq 0x1f3a20(%rip), %rax    # 0x40336a
jmp 0x20f95e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f97d
leaq 0xedf44(%rip), %rax     # 0x2fd8a2
movq %rax, 0x5c8bf3(%rip)    # 0x7d8558
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_table_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_table_striped_profile_64_pointer = parasail_nw_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_profile_64_pointer = parasail_nw_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_profile_64_pointer = parasail_nw_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_profile_64_pointer = parasail_nw_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_profile_64_pointer = parasail_nw_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_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 0x5c8fdb
testl %eax, %eax
je 0x20f9b2
leaq 0x2fb3fe(%rip), %rax    # 0x50adae
jmp 0x20f9d8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20f9c6
leaq 0x1ffbb6(%rip), %rax    # 0x40f57a
jmp 0x20f9d8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20f9f7
leaq 0xfbfaa(%rip), %rax     # 0x30b982
movq %rax, 0x5c8b81(%rip)    # 0x7d8560
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_table_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_table_striped_profile_32_pointer = parasail_nw_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_profile_32_pointer = parasail_nw_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_profile_32_pointer = parasail_nw_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_profile_32_pointer = parasail_nw_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_profile_32_pointer = parasail_nw_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_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 0x5c8fdb
testl %eax, %eax
je 0x20fa2c
leaq 0x2fcc2c(%rip), %rax    # 0x50c656
jmp 0x20fa52
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20fa40
leaq 0x201430(%rip), %rax    # 0x410e6e
jmp 0x20fa52
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20fa71
leaq 0xfe038(%rip), %rax     # 0x30da8a
movq %rax, 0x5c8b0f(%rip)    # 0x7d8568
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_table_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_table_striped_profile_16_pointer = parasail_nw_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_profile_16_pointer = parasail_nw_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_profile_16_pointer = parasail_nw_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_profile_16_pointer = parasail_nw_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_profile_16_pointer = parasail_nw_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_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 0x5c8fdb
testl %eax, %eax
je 0x20faa6
leaq 0x2fe76a(%rip), %rax    # 0x50e20e
jmp 0x20facc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20faba
leaq 0x202c92(%rip), %rax    # 0x41274a
jmp 0x20facc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20faeb
leaq 0xffcfa(%rip), %rax     # 0x30f7c6
movq %rax, 0x5c8a9d(%rip)    # 0x7d8570
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_table_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_table_striped_profile_8_pointer = parasail_nw_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_profile_8_pointer = parasail_nw_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_profile_8_pointer = parasail_nw_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_profile_8_pointer = parasail_nw_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_profile_8_pointer = parasail_nw_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_table_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 0x5c8fdb
testl %eax, %eax
je 0x20fb20
leaq 0x3015e0(%rip), %rax    # 0x5110fe
jmp 0x20fb46
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20fb34
leaq 0x204dc4(%rip), %rax    # 0x4148f6
jmp 0x20fb46
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20fb65
leaq 0x102170(%rip), %rax    # 0x311cb6
movq %rax, 0x5c8a2b(%rip)    # 0x7d8578
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_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_stats_table_scan_profile_64_pointer = parasail_nw_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_profile_64_pointer = parasail_nw_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_profile_64_pointer = parasail_nw_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_profile_64_pointer = parasail_nw_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_profile_64_pointer = parasail_nw_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20fb9a
leaq 0x3058a6(%rip), %rax    # 0x51543e
jmp 0x20fbc0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20fbae
leaq 0x20817a(%rip), %rax    # 0x417d26
jmp 0x20fbc0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20fbdf
leaq 0x10569e(%rip), %rax    # 0x31525e
movq %rax, 0x5c89b9(%rip)    # 0x7d8580
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_stats_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_stats_table_scan_profile_32_pointer = parasail_nw_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_profile_32_pointer = parasail_nw_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_profile_32_pointer = parasail_nw_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_profile_32_pointer = parasail_nw_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_profile_32_pointer = parasail_nw_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_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 0x5c8fdb
testl %eax, %eax
je 0x20fc14
leaq 0x308de8(%rip), %rax    # 0x5189fa
jmp 0x20fc3a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20fc28
leaq 0x20b49c(%rip), %rax    # 0x41b0c2
jmp 0x20fc3a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20fc59
leaq 0x1098cc(%rip), %rax    # 0x319506
movq %rax, 0x5c8947(%rip)    # 0x7d8588
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_stats_table_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_table_scan_profile_16_pointer = parasail_nw_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_profile_16_pointer = parasail_nw_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_profile_16_pointer = parasail_nw_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_profile_16_pointer = parasail_nw_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_profile_16_pointer = parasail_nw_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_table_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 0x5c8fdb
testl %eax, %eax
je 0x20fc8e
leaq 0x30c4ce(%rip), %rax    # 0x51c15a
jmp 0x20fcb4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20fca2
leaq 0x20e99a(%rip), %rax    # 0x41e63a
jmp 0x20fcb4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20fcd3
leaq 0x10d51a(%rip), %rax    # 0x31d1ce
movq %rax, 0x5c88d5(%rip)    # 0x7d8590
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_stats_table_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_table_scan_profile_8_pointer = parasail_nw_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_profile_8_pointer = parasail_nw_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_profile_8_pointer = parasail_nw_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_profile_8_pointer = parasail_nw_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_profile_8_pointer = parasail_nw_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_table_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 0x5c8fdb
testl %eax, %eax
je 0x20fd08
leaq 0x31109c(%rip), %rax    # 0x520da2
jmp 0x20fd2e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20fd1c
leaq 0x2127f8(%rip), %rax    # 0x422512
jmp 0x20fd2e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20fd4d
leaq 0x111a90(%rip), %rax    # 0x3217be
movq %rax, 0x5c8863(%rip)    # 0x7d8598
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_table_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_table_striped_profile_64_pointer = parasail_nw_stats_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_striped_profile_64_pointer = parasail_nw_stats_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_striped_profile_64_pointer = parasail_nw_stats_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_striped_profile_64_pointer = parasail_nw_stats_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_striped_profile_64_pointer = parasail_nw_stats_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_table_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 0x5c8fdb
testl %eax, %eax
je 0x20fd82
leaq 0x32bf2e(%rip), %rax    # 0x53bcae
jmp 0x20fda8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20fd96
leaq 0x2284ba(%rip), %rax    # 0x43824e
jmp 0x20fda8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x20fdc7
leaq 0x12a766(%rip), %rax    # 0x33a50e
movq %rax, 0x5c87f1(%rip)    # 0x7d85a0
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