LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x5672cf
testl %eax, %eax
je 0x1d7508
leaq 0x2dc4b7(%rip), %rax    # 0x4b39bd
jmp 0x1d752e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d751c
leaq 0x1deb93(%rip), %rax    # 0x3b60ad
jmp 0x1d752e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d754d
leaq 0xda70a(%rip), %rax     # 0x2b1c38
movq %rax, 0x566333(%rip)    # 0x73d868
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d7582
leaq 0x2de7e4(%rip), %rax    # 0x4b5d64
jmp 0x1d75a8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7596
leaq 0x1e0bac(%rip), %rax    # 0x3b8140
jmp 0x1d75a8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d75c7
leaq 0xdc821(%rip), %rax     # 0x2b3dc9
movq %rax, 0x5662c1(%rip)    # 0x73d870
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d75fc
leaq 0x2e10f7(%rip), %rax    # 0x4b86f1
jmp 0x1d7622
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7610
leaq 0x1e2ea0(%rip), %rax    # 0x3ba4ae
jmp 0x1d7622
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7641
leaq 0xded06(%rip), %rax     # 0x2b6328
movq %rax, 0x56624f(%rip)    # 0x73d878
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d7676
leaq 0x2e4f51(%rip), %rax    # 0x4bc5c5
jmp 0x1d769c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d768a
leaq 0x1e6fef(%rip), %rax    # 0x3be677
jmp 0x1d769c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d76bb
leaq 0xe2fe0(%rip), %rax     # 0x2ba67c
movq %rax, 0x5661dd(%rip)    # 0x73d880
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d76f0
leaq 0x2e8d56(%rip), %rax    # 0x4c0444
jmp 0x1d7716
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7704
leaq 0x1eaae6(%rip), %rax    # 0x3c21e8
jmp 0x1d7716
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7735
leaq 0xe7469(%rip), %rax     # 0x2beb7f
movq %rax, 0x56616b(%rip)    # 0x73d888
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d776a
leaq 0x2ecad4(%rip), %rax    # 0x4c423c
jmp 0x1d7790
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d777e
leaq 0x1ee523(%rip), %rax    # 0x3c5c9f
jmp 0x1d7790
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d77af
leaq 0xeb368(%rip), %rax     # 0x2c2af8
movq %rax, 0x5660f9(%rip)    # 0x73d890
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d77e4
leaq 0x2f0de9(%rip), %rax    # 0x4c85cb
jmp 0x1d780a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d77f8
leaq 0x1f2260(%rip), %rax    # 0x3c9a56
jmp 0x1d780a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7829
leaq 0xef596(%rip), %rax     # 0x2c6da0
movq %rax, 0x566087(%rip)    # 0x73d898
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d785e
leaq 0x30a0e7(%rip), %rax    # 0x4e1943
jmp 0x1d7884
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7872
leaq 0x207718(%rip), %rax    # 0x3def88
jmp 0x1d7884
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d78a3
leaq 0x107864(%rip), %rax    # 0x2df0e8
movq %rax, 0x566015(%rip)    # 0x73d8a0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d78d8
leaq 0x30dfd5(%rip), %rax    # 0x4e58ab
jmp 0x1d78fe
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d78ec
leaq 0x20b3a2(%rip), %rax    # 0x3e2c8c
jmp 0x1d78fe
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d791d
leaq 0x10bda4(%rip), %rax    # 0x2e36a2
movq %rax, 0x565fa3(%rip)    # 0x73d8a8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d7952
leaq 0x312093(%rip), %rax    # 0x4e99e3
jmp 0x1d7978
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7966
leaq 0x20f190(%rip), %rax    # 0x3e6af4
jmp 0x1d7978
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7997
leaq 0x10fef5(%rip), %rax    # 0x2e786d
movq %rax, 0x565f31(%rip)    # 0x73d8b0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d79cc
leaq 0x3167b2(%rip), %rax    # 0x4ee17c
jmp 0x1d79f2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d79e0
leaq 0x2132c9(%rip), %rax    # 0x3eaca7
jmp 0x1d79f2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7a11
leaq 0x114456(%rip), %rax    # 0x2ebe48
movq %rax, 0x565ebf(%rip)    # 0x73d8b8
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_scan_profile_64_pointer = parasail_sg_dx_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_profile_64_pointer = parasail_sg_dx_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_profile_64_pointer = parasail_sg_dx_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_profile_64_pointer = parasail_sg_dx_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_profile_64_pointer = parasail_sg_dx_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7a46
leaq 0x31992f(%rip), %rax    # 0x4f1373
jmp 0x1d7a6c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7a5a
leaq 0x215ed8(%rip), %rax    # 0x3ed930
jmp 0x1d7a6c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7a8b
leaq 0x11776b(%rip), %rax    # 0x2ef1d7
movq %rax, 0x565e4d(%rip)    # 0x73d8c0
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_scan_profile_32_pointer = parasail_sg_dx_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_profile_32_pointer = parasail_sg_dx_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_profile_32_pointer = parasail_sg_dx_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_profile_32_pointer = parasail_sg_dx_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_profile_32_pointer = parasail_sg_dx_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7ac0
leaq 0x31b7ca(%rip), %rax    # 0x4f3288
jmp 0x1d7ae6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7ad4
leaq 0x217bab(%rip), %rax    # 0x3ef67d
jmp 0x1d7ae6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7b05
leaq 0x11990d(%rip), %rax    # 0x2f13f3
movq %rax, 0x565ddb(%rip)    # 0x73d8c8
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_scan_profile_16_pointer = parasail_sg_dx_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_profile_16_pointer = parasail_sg_dx_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_profile_16_pointer = parasail_sg_dx_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_profile_16_pointer = parasail_sg_dx_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_profile_16_pointer = parasail_sg_dx_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7b3a
leaq 0x31d878(%rip), %rax    # 0x4f53b0
jmp 0x1d7b60
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7b4e
leaq 0x2199ba(%rip), %rax    # 0x3f1506
jmp 0x1d7b60
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7b7f
leaq 0x11b890(%rip), %rax    # 0x2f33f0
movq %rax, 0x565d69(%rip)    # 0x73d8d0
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_scan_profile_8_pointer = parasail_sg_dx_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_profile_8_pointer = parasail_sg_dx_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_profile_8_pointer = parasail_sg_dx_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_profile_8_pointer = parasail_sg_dx_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_profile_8_pointer = parasail_sg_dx_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7bb4
leaq 0x31fe53(%rip), %rax    # 0x4f7a05
jmp 0x1d7bda
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7bc8
leaq 0x21ba0f(%rip), %rax    # 0x3f35d5
jmp 0x1d7bda
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7bf9
leaq 0x11dbb1(%rip), %rax    # 0x2f578b
movq %rax, 0x565cf7(%rip)    # 0x73d8d8
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_striped_profile_64_pointer = parasail_sg_dx_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_profile_64_pointer = parasail_sg_dx_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_profile_64_pointer = parasail_sg_dx_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_profile_64_pointer = parasail_sg_dx_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_profile_64_pointer = parasail_sg_dx_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7c2e
leaq 0x331d95(%rip), %rax    # 0x5099c1
jmp 0x1d7c54
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7c42
leaq 0x2284ac(%rip), %rax    # 0x4000ec
jmp 0x1d7c54
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7c73
leaq 0x12c3be(%rip), %rax    # 0x304012
movq %rax, 0x565c85(%rip)    # 0x73d8e0
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_striped_profile_32_pointer = parasail_sg_dx_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_profile_32_pointer = parasail_sg_dx_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_profile_32_pointer = parasail_sg_dx_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_profile_32_pointer = parasail_sg_dx_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_profile_32_pointer = parasail_sg_dx_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7ca8
leaq 0x333a1e(%rip), %rax    # 0x50b6c4
jmp 0x1d7cce
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7cbc
leaq 0x22a019(%rip), %rax    # 0x401cd3
jmp 0x1d7cce
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7ced
leaq 0x12e394(%rip), %rax    # 0x306062
movq %rax, 0x565c13(%rip)    # 0x73d8e8
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_striped_profile_16_pointer = parasail_sg_dx_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_profile_16_pointer = parasail_sg_dx_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_profile_16_pointer = parasail_sg_dx_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_profile_16_pointer = parasail_sg_dx_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_profile_16_pointer = parasail_sg_dx_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7d22
leaq 0x335839(%rip), %rax    # 0x50d559
jmp 0x1d7d48
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7d36
leaq 0x22bbb6(%rip), %rax    # 0x4038ea
jmp 0x1d7d48
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7d67
leaq 0x13006f(%rip), %rax    # 0x307db7
movq %rax, 0x565ba1(%rip)    # 0x73d8f0
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_rowcol_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_rowcol_striped_profile_8_pointer = parasail_sg_dx_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_profile_8_pointer = parasail_sg_dx_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_profile_8_pointer = parasail_sg_dx_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_profile_8_pointer = parasail_sg_dx_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_profile_8_pointer = parasail_sg_dx_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7d9c
leaq 0x337c1b(%rip), %rax    # 0x50f9b5
jmp 0x1d7dc2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7db0
leaq 0x22d9ef(%rip), %rax    # 0x40579d
jmp 0x1d7dc2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7de1
leaq 0x132158(%rip), %rax    # 0x309f1a
movq %rax, 0x565b2f(%rip)    # 0x73d8f8
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_rowcol_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_rowcol_scan_profile_64_pointer = parasail_sg_dx_stats_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_profile_64_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_profile_64_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_profile_64_pointer = parasail_sg_dx_stats_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_profile_64_pointer = parasail_sg_dx_stats_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7e16
leaq 0x33bb94(%rip), %rax    # 0x5139a8
jmp 0x1d7e3c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7e2a
leaq 0x231a92(%rip), %rax    # 0x4098ba
jmp 0x1d7e3c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7e5b
leaq 0x136419(%rip), %rax    # 0x30e255
movq %rax, 0x565abd(%rip)    # 0x73d900
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_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_rowcol_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_rowcol_scan_profile_32_pointer = parasail_sg_dx_stats_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_profile_32_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_profile_32_pointer = parasail_sg_dx_stats_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_profile_32_pointer = parasail_sg_dx_stats_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_profile_32_pointer = parasail_sg_dx_stats_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_stats_rowcol_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 0x5672cf
testl %eax, %eax
je 0x1d7e90
leaq 0x33fb25(%rip), %rax    # 0x5179b3
jmp 0x1d7eb6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d7ea4
leaq 0x2356db(%rip), %rax    # 0x40d57d
jmp 0x1d7eb6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d7ed5
leaq 0x13a9c2(%rip), %rax    # 0x312878
movq %rax, 0x565a4b(%rip)    # 0x73d908
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