LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_profile_16_pointer = parasail_sw_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x21762e
leaq 0x282e4e(%rip), %rax    # 0x49a47a
jmp 0x217654
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217642
leaq 0x19c0a6(%rip), %rax    # 0x3b36e6
jmp 0x217654
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217673
leaq 0xa696a(%rip), %rax     # 0x2bdfbe
movq %rax, 0x58b755(%rip)    # 0x7a2db0
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/sw_dispatch.c
// Function: parasail_sw_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_profile_8_pointer = parasail_sw_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x2176a8
leaq 0x2842ac(%rip), %rax    # 0x49b952
jmp 0x2176ce
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2176bc
leaq 0x19d500(%rip), %rax    # 0x3b4bba
jmp 0x2176ce
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2176ed
leaq 0xa8024(%rip), %rax     # 0x2bf6f2
movq %rax, 0x58b6e3(%rip)    # 0x7a2db8
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x217722
leaq 0x28747a(%rip), %rax    # 0x49eb9a
jmp 0x217748
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217736
leaq 0x1a0612(%rip), %rax    # 0x3b7d46
jmp 0x217748
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217767
leaq 0xaaf62(%rip), %rax     # 0x2c26aa
movq %rax, 0x58b671(%rip)    # 0x7a2dc0
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x21779c
leaq 0x28a864(%rip), %rax    # 0x4a1ffe
jmp 0x2177c2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2177b0
leaq 0x1a364c(%rip), %rax    # 0x3badfa
jmp 0x2177c2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2177e1
leaq 0xae5c4(%rip), %rax     # 0x2c5d86
movq %rax, 0x58b5ff(%rip)    # 0x7a2dc8
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x217816
leaq 0x28d686(%rip), %rax    # 0x4a4e9a
jmp 0x21783c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21782a
leaq 0x1a640e(%rip), %rax    # 0x3bdc36
jmp 0x21783c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21785b
leaq 0xb181e(%rip), %rax     # 0x2c905a
movq %rax, 0x58b58d(%rip)    # 0x7a2dd0
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x217890
leaq 0x2904d0(%rip), %rax    # 0x4a7d5e
jmp 0x2178b6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2178a4
leaq 0x1a9270(%rip), %rax    # 0x3c0b12
jmp 0x2178b6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2178d5
leaq 0xb4c3c(%rip), %rax     # 0x2cc4f2
movq %rax, 0x58b51b(%rip)    # 0x7a2dd8
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x21790a
leaq 0x2a4ede(%rip), %rax    # 0x4bc7e6
jmp 0x217930
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21791e
leaq 0x1ba966(%rip), %rax    # 0x3d2282
jmp 0x217930
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21794f
leaq 0xc8432(%rip), %rax     # 0x2dfd62
movq %rax, 0x58b4a9(%rip)    # 0x7a2de0
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x217984
leaq 0x2a7e74(%rip), %rax    # 0x4bf7f6
jmp 0x2179aa
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217998
leaq 0x1bd6fc(%rip), %rax    # 0x3d5092
jmp 0x2179aa
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2179c9
leaq 0xcb828(%rip), %rax     # 0x2e31d2
movq %rax, 0x58b437(%rip)    # 0x7a2de8
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x2179fe
leaq 0x2aa9aa(%rip), %rax    # 0x4c23a6
jmp 0x217a24
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217a12
leaq 0x1c029e(%rip), %rax    # 0x3d7cae
jmp 0x217a24
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217a43
leaq 0xce77e(%rip), %rax     # 0x2e61a2
movq %rax, 0x58b3c5(%rip)    # 0x7a2df0
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x217a78
leaq 0x2ad578(%rip), %rax    # 0x4c4fee
jmp 0x217a9e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217a8c
leaq 0x1c2ee4(%rip), %rax    # 0x3da96e
jmp 0x217a9e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217abd
leaq 0xd1920(%rip), %rax     # 0x2e93be
movq %rax, 0x58b353(%rip)    # 0x7a2df8
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/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x217af2
leaq 0x2b115e(%rip), %rax    # 0x4c8c4e
jmp 0x217b18
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217b06
leaq 0x1c5226(%rip), %rax    # 0x3dcd2a
jmp 0x217b18
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217b37
leaq 0xd4e7e(%rip), %rax     # 0x2ec996
movq %rax, 0x58b2e1(%rip)    # 0x7a2e00
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/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x217b6c
leaq 0x2b3080(%rip), %rax    # 0x4cabea
jmp 0x217b92
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217b80
leaq 0x1c6b30(%rip), %rax    # 0x3de6ae
jmp 0x217b92
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217bb1
leaq 0xd69e8(%rip), %rax     # 0x2ee57a
movq %rax, 0x58b26f(%rip)    # 0x7a2e08
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/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217be6
leaq 0x2b4ea2(%rip), %rax    # 0x4cca86
jmp 0x217c0c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217bfa
leaq 0x1c8576(%rip), %rax    # 0x3e016e
jmp 0x217c0c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217c2b
leaq 0xd853e(%rip), %rax     # 0x2f014a
movq %rax, 0x58b1fd(%rip)    # 0x7a2e10
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/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217c60
leaq 0x2b71d0(%rip), %rax    # 0x4cee2e
jmp 0x217c86
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217c74
leaq 0x1ca3c0(%rip), %rax    # 0x3e2032
jmp 0x217c86
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217ca5
leaq 0xda68c(%rip), %rax     # 0x2f2312
movq %rax, 0x58b18b(%rip)    # 0x7a2e18
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/sw_dispatch.c
// Function: parasail_sw_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217cda
leaq 0x2c852e(%rip), %rax    # 0x4e0206
jmp 0x217d00
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217cee
leaq 0x1d607e(%rip), %rax    # 0x3edd6a
jmp 0x217d00
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217d1f
leaq 0xe73ce(%rip), %rax     # 0x2ff0ce
movq %rax, 0x58b119(%rip)    # 0x7a2e20
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/sw_dispatch.c
// Function: parasail_sw_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217d54
leaq 0x2ca094(%rip), %rax    # 0x4e1de6
jmp 0x217d7a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217d68
leaq 0x1d7828(%rip), %rax    # 0x3ef58e
jmp 0x217d7a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217d99
leaq 0xe8dc8(%rip), %rax     # 0x300b42
movq %rax, 0x58b0a7(%rip)    # 0x7a2e28
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/sw_dispatch.c
// Function: parasail_sw_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_profile_16_pointer = parasail_sw_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_profile_16_pointer = parasail_sw_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_profile_16_pointer = parasail_sw_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_profile_16_pointer = parasail_sw_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_profile_16_pointer = parasail_sw_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217dce
leaq 0x2cc00e(%rip), %rax    # 0x4e3dda
jmp 0x217df4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217de2
leaq 0x1d911a(%rip), %rax    # 0x3f0efa
jmp 0x217df4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217e13
leaq 0xea77e(%rip), %rax     # 0x302572
movq %rax, 0x58b035(%rip)    # 0x7a2e30
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/sw_dispatch.c
// Function: parasail_sw_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_profile_8_pointer = parasail_sw_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_profile_8_pointer = parasail_sw_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_profile_8_pointer = parasail_sw_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_profile_8_pointer = parasail_sw_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_profile_8_pointer = parasail_sw_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217e48
leaq 0x2ce628(%rip), %rax    # 0x4e646e
jmp 0x217e6e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217e5c
leaq 0x1db078(%rip), %rax    # 0x3f2ed2
jmp 0x217e6e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217e8d
leaq 0xecaa4(%rip), %rax     # 0x304912
movq %rax, 0x58afc3(%rip)    # 0x7a2e38
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_profile_64_pointer = parasail_sw_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_profile_64_pointer = parasail_sw_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_profile_64_pointer = parasail_sw_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_profile_64_pointer = parasail_sw_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_profile_64_pointer = parasail_sw_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217ec2
leaq 0x2d2242(%rip), %rax    # 0x4ea102
jmp 0x217ee8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217ed6
leaq 0x1dea02(%rip), %rax    # 0x3f68d6
jmp 0x217ee8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217f07
leaq 0xf00d6(%rip), %rax     # 0x307fbe
movq %rax, 0x58af51(%rip)    # 0x7a2e40
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_profile_32_pointer = parasail_sw_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_profile_32_pointer = parasail_sw_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_profile_32_pointer = parasail_sw_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_profile_32_pointer = parasail_sw_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_profile_32_pointer = parasail_sw_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217f3c
leaq 0x2d5d24(%rip), %rax    # 0x4edc5e
jmp 0x217f62
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217f50
leaq 0x1e1ea8(%rip), %rax    # 0x3f9df6
jmp 0x217f62
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217f81
leaq 0xf3b68(%rip), %rax     # 0x30baca
movq %rax, 0x58aedf(%rip)    # 0x7a2e48
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_profile_16_pointer = parasail_sw_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_profile_16_pointer = parasail_sw_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_profile_16_pointer = parasail_sw_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_profile_16_pointer = parasail_sw_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_profile_16_pointer = parasail_sw_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x217fb6
leaq 0x2d9afe(%rip), %rax    # 0x4f1ab2
jmp 0x217fdc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217fca
leaq 0x1e55ae(%rip), %rax    # 0x3fd576
jmp 0x217fdc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217ffb
leaq 0xf76ce(%rip), %rax     # 0x30f6aa
movq %rax, 0x58ae6d(%rip)    # 0x7a2e50
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/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_profile_8_pointer = parasail_sw_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_profile_8_pointer = parasail_sw_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_profile_8_pointer = parasail_sw_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_profile_8_pointer = parasail_sw_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_profile_8_pointer = parasail_sw_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x218030
leaq 0x2ddd5c(%rip), %rax    # 0x4f5d8a
jmp 0x218056
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x218044
leaq 0x1e951c(%rip), %rax    # 0x40155e
jmp 0x218056
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x218075
leaq 0xfbb98(%rip), %rax     # 0x313bee
movq %rax, 0x58adfb(%rip)    # 0x7a2e58
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