LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5c8fdb
testl %eax, %eax
je 0x23596e
leaq 0x298ff6(%rip), %rax    # 0x4ce962
jmp 0x235994
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235982
leaq 0x1a9203(%rip), %rax    # 0x3deb83
jmp 0x235994
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2359b3
leaq 0x9b9b0(%rip), %rax     # 0x2d1344
movq %rax, 0x5a4e75(%rip)    # 0x7da810
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x2359e8
leaq 0x29d276(%rip), %rax    # 0x4d2c5c
jmp 0x235a0e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2359fc
leaq 0x1aca12(%rip), %rax    # 0x3e240c
jmp 0x235a0e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235a2d
leaq 0x9feb9(%rip), %rax     # 0x2d58c7
movq %rax, 0x5a4e03(%rip)    # 0x7da818
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235a62
leaq 0x2b02ac(%rip), %rax    # 0x4e5d0c
jmp 0x235a88
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235a76
leaq 0x1bd9d5(%rip), %rax    # 0x3f3449
jmp 0x235a88
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235aa7
leaq 0xb40f2(%rip), %rax     # 0x2e9b7a
movq %rax, 0x5a4d91(%rip)    # 0x7da820
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235adc
leaq 0x2b2f6e(%rip), %rax    # 0x4e8a48
jmp 0x235b02
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235af0
leaq 0x1c07db(%rip), %rax    # 0x3f62c9
jmp 0x235b02
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235b21
leaq 0xb7a37(%rip), %rax     # 0x2ed539
movq %rax, 0x5a4d1f(%rip)    # 0x7da828
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235b56
leaq 0x2b668a(%rip), %rax    # 0x4ec1de
jmp 0x235b7c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235b6a
leaq 0x1c3972(%rip), %rax    # 0x3f94da
jmp 0x235b7c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235b9b
leaq 0xbb0f2(%rip), %rax     # 0x2f0c6e
movq %rax, 0x5a4cad(%rip)    # 0x7da830
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235bd0
leaq 0x2bad27(%rip), %rax    # 0x4f08f5
jmp 0x235bf6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235be4
leaq 0x1c6ef6(%rip), %rax    # 0x3fcad8
jmp 0x235bf6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235c15
leaq 0xbf19e(%rip), %rax     # 0x2f4d94
movq %rax, 0x5a4c3b(%rip)    # 0x7da838
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235c4a
leaq 0x2be12f(%rip), %rax    # 0x4f3d77
jmp 0x235c70
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235c5e
leaq 0x1c90e7(%rip), %rax    # 0x3fed43
jmp 0x235c70
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235c8f
leaq 0xc2c5d(%rip), %rax     # 0x2f88cd
movq %rax, 0x5a4bc9(%rip)    # 0x7da840
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235cc4
leaq 0x2bfd78(%rip), %rax    # 0x4f5a3a
jmp 0x235cea
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235cd8
leaq 0x1cac04(%rip), %rax    # 0x4008da
jmp 0x235cea
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235d09
leaq 0xc4c3f(%rip), %rax     # 0x2fa929
movq %rax, 0x5a4b57(%rip)    # 0x7da848
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235d3e
leaq 0x2c28dd(%rip), %rax    # 0x4f8619
jmp 0x235d64
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235d52
leaq 0x1ccbcd(%rip), %rax    # 0x40291d
jmp 0x235d64
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235d83
leaq 0xc7057(%rip), %rax     # 0x2fcdbb
movq %rax, 0x5a4ae5(%rip)    # 0x7da850
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235db8
leaq 0x2c66ff(%rip), %rax    # 0x4fc4b5
jmp 0x235dde
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235dcc
leaq 0x1cf34c(%rip), %rax    # 0x405116
jmp 0x235dde
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235dfd
leaq 0xca128(%rip), %rax     # 0x2fff06
movq %rax, 0x5a4a73(%rip)    # 0x7da858
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235e32
leaq 0x2d6019(%rip), %rax    # 0x50be49
jmp 0x235e58
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235e46
leaq 0x1da886(%rip), %rax    # 0x4106ca
jmp 0x235e58
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235e77
leaq 0xd72bc(%rip), %rax     # 0x30d114
movq %rax, 0x5a4a01(%rip)    # 0x7da860
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235eac
leaq 0x2d7a3f(%rip), %rax    # 0x50d8e9
jmp 0x235ed2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235ec0
leaq 0x1dc100(%rip), %rax    # 0x411fbe
jmp 0x235ed2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235ef1
leaq 0xd901c(%rip), %rax     # 0x30eeee
movq %rax, 0x5a498f(%rip)    # 0x7da868
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x235f26
leaq 0x2da5fa(%rip), %rax    # 0x51051e
jmp 0x235f4c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235f3a
leaq 0x1ddfe3(%rip), %rax    # 0x413f1b
jmp 0x235f4c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235f6b
leaq 0xdb2f7(%rip), %rax     # 0x311243
movq %rax, 0x5a491d(%rip)    # 0x7da870
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_table_striped_profile_8_pointer = parasail_sg_dx_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_profile_8_pointer = parasail_sg_dx_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_profile_8_pointer = parasail_sg_dx_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_profile_8_pointer = parasail_sg_dx_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_profile_8_pointer = parasail_sg_dx_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_table_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x235fa0
leaq 0x2de67b(%rip), %rax    # 0x514619
jmp 0x235fc6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x235fb4
leaq 0x1e08df(%rip), %rax    # 0x416891
jmp 0x235fc6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x235fe5
leaq 0xde4d1(%rip), %rax     # 0x314497
movq %rax, 0x5a48ab(%rip)    # 0x7da878
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_table_scan_profile_64_pointer = parasail_sg_dx_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_profile_64_pointer = parasail_sg_dx_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_profile_64_pointer = parasail_sg_dx_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_profile_64_pointer = parasail_sg_dx_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_profile_64_pointer = parasail_sg_dx_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23601a
leaq 0x2e18c5(%rip), %rax    # 0x5178dd
jmp 0x236040
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23602e
leaq 0x1e4009(%rip), %rax    # 0x41a035
jmp 0x236040
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23605f
leaq 0xe1ff1(%rip), %rax     # 0x318031
movq %rax, 0x5a4839(%rip)    # 0x7da880
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_table_scan_profile_32_pointer = parasail_sg_dx_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_profile_32_pointer = parasail_sg_dx_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_profile_32_pointer = parasail_sg_dx_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_profile_32_pointer = parasail_sg_dx_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_profile_32_pointer = parasail_sg_dx_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x236094
leaq 0x2e4f25(%rip), %rax    # 0x51afb7
jmp 0x2360ba
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2360a8
leaq 0x1e7487(%rip), %rax    # 0x41d52d
jmp 0x2360ba
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2360d9
leaq 0xe5d50(%rip), %rax     # 0x31be0a
movq %rax, 0x5a47c7(%rip)    # 0x7da888
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_table_scan_profile_16_pointer = parasail_sg_dx_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_profile_16_pointer = parasail_sg_dx_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_profile_16_pointer = parasail_sg_dx_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_profile_16_pointer = parasail_sg_dx_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_profile_16_pointer = parasail_sg_dx_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23610e
leaq 0x2e9614(%rip), %rax    # 0x51f720
jmp 0x236134
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x236122
leaq 0x1eb0bd(%rip), %rax    # 0x4211dd
jmp 0x236134
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x236153
leaq 0xea1e8(%rip), %rax     # 0x32031c
movq %rax, 0x5a4755(%rip)    # 0x7da890
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_table_scan_profile_8_pointer = parasail_sg_dx_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_profile_8_pointer = parasail_sg_dx_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_profile_8_pointer = parasail_sg_dx_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_profile_8_pointer = parasail_sg_dx_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_profile_8_pointer = parasail_sg_dx_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x236188
leaq 0x2eedb3(%rip), %rax    # 0x524f39
jmp 0x2361ae
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23619c
leaq 0x1efaa0(%rip), %rax    # 0x425c3a
jmp 0x2361ae
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2361cd
leaq 0xef8b6(%rip), %rax     # 0x325a64
movq %rax, 0x5a46e3(%rip)    # 0x7da898
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_striped_profile_64_pointer = parasail_sg_dx_stats_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_profile_64_pointer = parasail_sg_dx_stats_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_profile_64_pointer = parasail_sg_dx_stats_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_profile_64_pointer = parasail_sg_dx_stats_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_profile_64_pointer = parasail_sg_dx_stats_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x236202
leaq 0x307c9e(%rip), %rax    # 0x53de9e
jmp 0x236228
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x236216
leaq 0x2041ec(%rip), %rax    # 0x43a400
jmp 0x236228
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x236247
leaq 0x106f79(%rip), %rax    # 0x33d1a1
movq %rax, 0x5a4671(%rip)    # 0x7da8a0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_table_striped_profile_32_pointer = parasail_sg_dx_stats_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_profile_32_pointer = parasail_sg_dx_stats_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_profile_32_pointer = parasail_sg_dx_stats_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_profile_32_pointer = parasail_sg_dx_stats_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_profile_32_pointer = parasail_sg_dx_stats_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23627c
leaq 0x30b27f(%rip), %rax    # 0x5414f9
jmp 0x2362a2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x236290
leaq 0x207596(%rip), %rax    # 0x43d824
jmp 0x2362a2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2362c1
leaq 0x10ad96(%rip), %rax    # 0x341038
movq %rax, 0x5a45ff(%rip)    # 0x7da8a8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_table_striped_profile_16_pointer = parasail_sg_dx_stats_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_profile_16_pointer = parasail_sg_dx_stats_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_profile_16_pointer = parasail_sg_dx_stats_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_profile_16_pointer = parasail_sg_dx_stats_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_profile_16_pointer = parasail_sg_dx_stats_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2362f6
leaq 0x3102b0(%rip), %rax    # 0x5465a4
jmp 0x23631c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23630a
leaq 0x20b4d8(%rip), %rax    # 0x4417e0
jmp 0x23631c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23633b
leaq 0x10f233(%rip), %rax    # 0x34554f
movq %rax, 0x5a458d(%rip)    # 0x7da8b0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_sg_dx_stats_table_striped_profile_8_pointer = parasail_sg_dx_stats_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_profile_8_pointer = parasail_sg_dx_stats_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_profile_8_pointer = parasail_sg_dx_stats_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_profile_8_pointer = parasail_sg_dx_stats_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_profile_8_pointer = parasail_sg_dx_stats_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_table_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x236370
leaq 0x31645e(%rip), %rax    # 0x54c7cc
jmp 0x236396
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x236384
leaq 0x21087d(%rip), %rax    # 0x446bff
jmp 0x236396
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2363b5
leaq 0x115120(%rip), %rax    # 0x34b4b6
movq %rax, 0x5a451b(%rip)    # 0x7da8b8
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