LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x233f2c
leaq 0x2542d6(%rip), %rax    # 0x488200
jmp 0x233f52
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x233f40
leaq 0x17079c(%rip), %rax    # 0x3a46da
jmp 0x233f52
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x233f71
leaq 0x79bba(%rip), %rax     # 0x2adb0c
movq %rax, 0x57086f(%rip)    # 0x7a47c8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x233fa6
leaq 0x25594b(%rip), %rax    # 0x4898ef
jmp 0x233fcc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x233fba
leaq 0x171df5(%rip), %rax    # 0x3a5dad
jmp 0x233fcc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x233feb
leaq 0x7b319(%rip), %rax     # 0x2af2e5
movq %rax, 0x5707fd(%rip)    # 0x7a47d0
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x234020
leaq 0x256f97(%rip), %rax    # 0x48afb5
jmp 0x234046
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234034
leaq 0x17343d(%rip), %rax    # 0x3a746f
jmp 0x234046
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234065
leaq 0x7cc2c(%rip), %rax     # 0x2b0c72
movq %rax, 0x57078b(%rip)    # 0x7a47d8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x23409a
leaq 0x26361f(%rip), %rax    # 0x4976b7
jmp 0x2340c0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2340ae
leaq 0x17ca04(%rip), %rax    # 0x3b0ab0
jmp 0x2340c0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2340df
leaq 0x87092(%rip), %rax     # 0x2bb152
movq %rax, 0x570719(%rip)    # 0x7a47e0
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_striped_profile_32_pointer = parasail_sg_dx_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_profile_32_pointer = parasail_sg_dx_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_profile_32_pointer = parasail_sg_dx_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_profile_32_pointer = parasail_sg_dx_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_profile_32_pointer = parasail_sg_dx_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x234114
leaq 0x264d66(%rip), %rax    # 0x498e78
jmp 0x23413a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234128
leaq 0x17dfc6(%rip), %rax    # 0x3b20ec
jmp 0x23413a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234159
leaq 0x887e4(%rip), %rax     # 0x2bc91e
movq %rax, 0x5706a7(%rip)    # 0x7a47e8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_striped_profile_16_pointer = parasail_sg_dx_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_profile_16_pointer = parasail_sg_dx_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_profile_16_pointer = parasail_sg_dx_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_profile_16_pointer = parasail_sg_dx_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_profile_16_pointer = parasail_sg_dx_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x23418e
leaq 0x26619a(%rip), %rax    # 0x49a326
jmp 0x2341b4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2341a2
leaq 0x17f3f1(%rip), %rax    # 0x3b3591
jmp 0x2341b4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2341d3
leaq 0x89cb5(%rip), %rax     # 0x2bde69
movq %rax, 0x570635(%rip)    # 0x7a47f0
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_striped_profile_8_pointer = parasail_sg_dx_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_profile_8_pointer = parasail_sg_dx_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_profile_8_pointer = parasail_sg_dx_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_profile_8_pointer = parasail_sg_dx_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_profile_8_pointer = parasail_sg_dx_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x234208
leaq 0x2675f8(%rip), %rax    # 0x49b7fe
jmp 0x23422e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23421c
leaq 0x18084c(%rip), %rax    # 0x3b4a66
jmp 0x23422e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23424d
leaq 0x8b36f(%rip), %rax     # 0x2bf59d
movq %rax, 0x5705c3(%rip)    # 0x7a47f8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_scan_profile_64_pointer = parasail_sg_dx_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_profile_64_pointer = parasail_sg_dx_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_profile_64_pointer = parasail_sg_dx_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_profile_64_pointer = parasail_sg_dx_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_profile_64_pointer = parasail_sg_dx_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x234282
leaq 0x26a7ba(%rip), %rax    # 0x49ea3a
jmp 0x2342a8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234296
leaq 0x183951(%rip), %rax    # 0x3b7be5
jmp 0x2342a8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2342c7
leaq 0x8e29f(%rip), %rax     # 0x2c2547
movq %rax, 0x570551(%rip)    # 0x7a4800
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_scan_profile_32_pointer = parasail_sg_dx_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_profile_32_pointer = parasail_sg_dx_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_profile_32_pointer = parasail_sg_dx_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_profile_32_pointer = parasail_sg_dx_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_profile_32_pointer = parasail_sg_dx_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2342fc
leaq 0x26dba3(%rip), %rax    # 0x4a1e9d
jmp 0x234322
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234310
leaq 0x18698b(%rip), %rax    # 0x3bac99
jmp 0x234322
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234341
leaq 0x91902(%rip), %rax     # 0x2c5c24
movq %rax, 0x5704df(%rip)    # 0x7a4808
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_scan_profile_16_pointer = parasail_sg_dx_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_profile_16_pointer = parasail_sg_dx_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_profile_16_pointer = parasail_sg_dx_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_profile_16_pointer = parasail_sg_dx_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_profile_16_pointer = parasail_sg_dx_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x234376
leaq 0x2709c5(%rip), %rax    # 0x4a4d39
jmp 0x23439c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23438a
leaq 0x18974c(%rip), %rax    # 0x3bdad4
jmp 0x23439c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2343bb
leaq 0x94b5d(%rip), %rax     # 0x2c8ef9
movq %rax, 0x57046d(%rip)    # 0x7a4810
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_scan_profile_8_pointer = parasail_sg_dx_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_profile_8_pointer = parasail_sg_dx_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_profile_8_pointer = parasail_sg_dx_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_profile_8_pointer = parasail_sg_dx_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_profile_8_pointer = parasail_sg_dx_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2343f0
leaq 0x27380d(%rip), %rax    # 0x4a7bfb
jmp 0x234416
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234404
leaq 0x18c5b0(%rip), %rax    # 0x3c09b2
jmp 0x234416
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234435
leaq 0x97f7c(%rip), %rax     # 0x2cc392
movq %rax, 0x5703fb(%rip)    # 0x7a4818
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_striped_profile_64_pointer = parasail_sg_dx_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_profile_64_pointer = parasail_sg_dx_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_profile_64_pointer = parasail_sg_dx_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_profile_64_pointer = parasail_sg_dx_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_profile_64_pointer = parasail_sg_dx_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x23446a
leaq 0x28821e(%rip), %rax    # 0x4bc686
jmp 0x234490
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23447e
leaq 0x19dca6(%rip), %rax    # 0x3d2122
jmp 0x234490
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2344af
leaq 0xab771(%rip), %rax     # 0x2dfc01
movq %rax, 0x570389(%rip)    # 0x7a4820
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_striped_profile_32_pointer = parasail_sg_dx_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_profile_32_pointer = parasail_sg_dx_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_profile_32_pointer = parasail_sg_dx_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_profile_32_pointer = parasail_sg_dx_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_profile_32_pointer = parasail_sg_dx_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2344e4
leaq 0x28b1b2(%rip), %rax    # 0x4bf694
jmp 0x23450a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2344f8
leaq 0x1a0a3a(%rip), %rax    # 0x3d4f30
jmp 0x23450a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234529
leaq 0xaeb67(%rip), %rax     # 0x2e3071
movq %rax, 0x570317(%rip)    # 0x7a4828
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_striped_profile_16_pointer = parasail_sg_dx_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_profile_16_pointer = parasail_sg_dx_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_profile_16_pointer = parasail_sg_dx_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_profile_16_pointer = parasail_sg_dx_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_profile_16_pointer = parasail_sg_dx_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x23455e
leaq 0x28dce8(%rip), %rax    # 0x4c2244
jmp 0x234584
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234572
leaq 0x1a35dc(%rip), %rax    # 0x3d7b4c
jmp 0x234584
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2345a3
leaq 0xb1abd(%rip), %rax     # 0x2e6041
movq %rax, 0x5702a5(%rip)    # 0x7a4830
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_striped_profile_8_pointer = parasail_sg_dx_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_profile_8_pointer = parasail_sg_dx_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_profile_8_pointer = parasail_sg_dx_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_profile_8_pointer = parasail_sg_dx_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_profile_8_pointer = parasail_sg_dx_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2345d8
leaq 0x2908b7(%rip), %rax    # 0x4c4e8d
jmp 0x2345fe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2345ec
leaq 0x1a6222(%rip), %rax    # 0x3da80c
jmp 0x2345fe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23461d
leaq 0xb4c60(%rip), %rax     # 0x2e925e
movq %rax, 0x570233(%rip)    # 0x7a4838
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_scan_profile_64_pointer = parasail_sg_dx_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_profile_64_pointer = parasail_sg_dx_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_profile_64_pointer = parasail_sg_dx_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_profile_64_pointer = parasail_sg_dx_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_profile_64_pointer = parasail_sg_dx_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x234652
leaq 0x2944aa(%rip), %rax    # 0x4c8afa
jmp 0x234678
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234666
leaq 0x1a8571(%rip), %rax    # 0x3dcbd5
jmp 0x234678
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234697
leaq 0xb81c7(%rip), %rax     # 0x2ec83f
movq %rax, 0x5701c1(%rip)    # 0x7a4840
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_scan_profile_32_pointer = parasail_sg_dx_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_profile_32_pointer = parasail_sg_dx_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_profile_32_pointer = parasail_sg_dx_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_profile_32_pointer = parasail_sg_dx_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_profile_32_pointer = parasail_sg_dx_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2346cc
leaq 0x2963ca(%rip), %rax    # 0x4caa94
jmp 0x2346f2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2346e0
leaq 0x1a9e7c(%rip), %rax    # 0x3de55a
jmp 0x2346f2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234711
leaq 0xb9d33(%rip), %rax     # 0x2ee425
movq %rax, 0x57014f(%rip)    # 0x7a4848
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_scan_profile_16_pointer = parasail_sg_dx_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_profile_16_pointer = parasail_sg_dx_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_profile_16_pointer = parasail_sg_dx_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_profile_16_pointer = parasail_sg_dx_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_profile_16_pointer = parasail_sg_dx_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x234746
leaq 0x2981ed(%rip), %rax    # 0x4cc931
jmp 0x23476c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23475a
leaq 0x1ab8c1(%rip), %rax    # 0x3e0019
jmp 0x23476c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23478b
leaq 0xbb887(%rip), %rax     # 0x2efff3
movq %rax, 0x5700dd(%rip)    # 0x7a4850
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_scan_profile_8_pointer = parasail_sg_dx_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_profile_8_pointer = parasail_sg_dx_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_profile_8_pointer = parasail_sg_dx_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_profile_8_pointer = parasail_sg_dx_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_profile_8_pointer = parasail_sg_dx_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2347c0
leaq 0x29a51b(%rip), %rax    # 0x4cecd9
jmp 0x2347e6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2347d4
leaq 0x1ad709(%rip), %rax    # 0x3e1edb
jmp 0x2347e6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234805
leaq 0xbd9d7(%rip), %rax     # 0x2f21bd
movq %rax, 0x57006b(%rip)    # 0x7a4858
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_striped_profile_64_pointer = parasail_sg_dx_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_profile_64_pointer = parasail_sg_dx_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_profile_64_pointer = parasail_sg_dx_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_profile_64_pointer = parasail_sg_dx_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_profile_64_pointer = parasail_sg_dx_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x23483a
leaq 0x2ab87a(%rip), %rax    # 0x4e00b2
jmp 0x234860
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23484e
leaq 0x1b93c8(%rip), %rax    # 0x3edc14
jmp 0x234860
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23487f
leaq 0xca718(%rip), %rax     # 0x2fef78
movq %rax, 0x56fff9(%rip)    # 0x7a4860
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_striped_profile_32_pointer = parasail_sg_dx_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_profile_32_pointer = parasail_sg_dx_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_profile_32_pointer = parasail_sg_dx_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_profile_32_pointer = parasail_sg_dx_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_profile_32_pointer = parasail_sg_dx_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2348b4
leaq 0x2ad3dd(%rip), %rax    # 0x4e1c8f
jmp 0x2348da
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2348c8
leaq 0x1bab74(%rip), %rax    # 0x3ef43a
jmp 0x2348da
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2348f9
leaq 0xcc111(%rip), %rax     # 0x3009eb
movq %rax, 0x56ff87(%rip)    # 0x7a4868
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_striped_profile_16_pointer = parasail_sg_dx_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_profile_16_pointer = parasail_sg_dx_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_profile_16_pointer = parasail_sg_dx_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_profile_16_pointer = parasail_sg_dx_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_profile_16_pointer = parasail_sg_dx_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x23492e
leaq 0x2af35a(%rip), %rax    # 0x4e3c86
jmp 0x234954
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x234942
leaq 0x1bc466(%rip), %rax    # 0x3f0da6
jmp 0x234954
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x234973
leaq 0xcdac8(%rip), %rax     # 0x30241c
movq %rax, 0x56ff15(%rip)    # 0x7a4870
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