LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x230b64
leaq 0x35f60d(%rip), %rax    # 0x59016f
jmp 0x230b8a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x230b78
leaq 0x24f4e2(%rip), %rax    # 0x480058
jmp 0x230b8a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x230ba9
leaq 0x16beb3(%rip), %rax    # 0x39ca3d
movq %rax, 0x573977(%rip)    # 0x7a4508
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x230bde
leaq 0x3616fd(%rip), %rax    # 0x5922d9
jmp 0x230c04
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x230bf2
leaq 0x25156f(%rip), %rax    # 0x48215f
jmp 0x230c04
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x230c23
leaq 0x16e088(%rip), %rax    # 0x39ec8c
movq %rax, 0x573905(%rip)    # 0x7a4510
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x230c58
leaq 0x36381b(%rip), %rax    # 0x594471
jmp 0x230c7e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x230c6c
leaq 0x25360f(%rip), %rax    # 0x484279
jmp 0x230c7e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x230c9d
leaq 0x170458(%rip), %rax    # 0x3a10d6
movq %rax, 0x573893(%rip)    # 0x7a4518
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2311c5
leaq 0x2553ae(%rip), %rax    # 0x486571
jmp 0x2311f4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2311d9
leaq 0x171b8f(%rip), %rax    # 0x3a2d66
jmp 0x2311f4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2311ed
leaq 0x697bd(%rip), %rax     # 0x29a9a8
jmp 0x2311f4
leaq 0x7ad67(%rip), %rax     # 0x2abf5b
movq %rax, 0x573325(%rip)    # 0x7a4520
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23124e
leaq 0x256e6b(%rip), %rax    # 0x4880b7
jmp 0x23127d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231262
leaq 0x173331(%rip), %rax    # 0x3a4591
jmp 0x23127d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231276
leaq 0x69734(%rip), %rax     # 0x29a9a8
jmp 0x23127d
leaq 0x7c746(%rip), %rax     # 0x2ad9c3
movq %rax, 0x5732a4(%rip)    # 0x7a4528
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2312d7
leaq 0x2584d1(%rip), %rax    # 0x4897a6
jmp 0x231306
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2312eb
leaq 0x17497b(%rip), %rax    # 0x3a5c64
jmp 0x231306
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2312ff
leaq 0x696ab(%rip), %rax     # 0x29a9a8
jmp 0x231306
leaq 0x7de96(%rip), %rax     # 0x2af19c
movq %rax, 0x573223(%rip)    # 0x7a4530
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231360
leaq 0x259b0e(%rip), %rax    # 0x48ae6c
jmp 0x23138f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231374
leaq 0x175fb4(%rip), %rax    # 0x3a7326
jmp 0x23138f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231388
leaq 0x69622(%rip), %rax     # 0x29a9a8
jmp 0x23138f
leaq 0x7f79a(%rip), %rax     # 0x2b0b29
movq %rax, 0x5731a2(%rip)    # 0x7a4538
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2313e9
leaq 0x266187(%rip), %rax    # 0x49756e
jmp 0x231418
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2313fd
leaq 0x17f56c(%rip), %rax    # 0x3b0967
jmp 0x231418
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231411
leaq 0x6871b(%rip), %rax     # 0x299b2a
jmp 0x231418
leaq 0x89bf1(%rip), %rax     # 0x2bb009
movq %rax, 0x573121(%rip)    # 0x7a4540
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231472
leaq 0x2678bf(%rip), %rax    # 0x498d2f
jmp 0x2314a1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231486
leaq 0x180b1f(%rip), %rax    # 0x3b1fa3
jmp 0x2314a1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23149a
leaq 0x68692(%rip), %rax     # 0x299b2a
jmp 0x2314a1
leaq 0x8b334(%rip), %rax     # 0x2bc7d5
movq %rax, 0x5730a0(%rip)    # 0x7a4548
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2314fb
leaq 0x268ce4(%rip), %rax    # 0x49a1dd
jmp 0x23152a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23150f
leaq 0x181f3b(%rip), %rax    # 0x3b3448
jmp 0x23152a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231523
leaq 0x68609(%rip), %rax     # 0x299b2a
jmp 0x23152a
leaq 0x8c7f6(%rip), %rax     # 0x2bdd20
movq %rax, 0x57301f(%rip)    # 0x7a4550
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231584
leaq 0x26a133(%rip), %rax    # 0x49b6b5
jmp 0x2315b3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231598
leaq 0x183387(%rip), %rax    # 0x3b491d
jmp 0x2315b3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2315ac
leaq 0x68580(%rip), %rax     # 0x299b2a
jmp 0x2315b3
leaq 0x8dea1(%rip), %rax     # 0x2bf454
movq %rax, 0x572f9e(%rip)    # 0x7a4558
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23160d
leaq 0x25b922(%rip), %rax    # 0x48cf2d
jmp 0x23163c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231621
leaq 0x177869(%rip), %rax    # 0x3a8e88
jmp 0x23163c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231635
leaq 0x684f7(%rip), %rax     # 0x299b2a
jmp 0x23163c
leaq 0x813fa(%rip), %rax     # 0x2b2a36
movq %rax, 0x572f1d(%rip)    # 0x7a4560
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231696
leaq 0x25d8a0(%rip), %rax    # 0x48ef34
jmp 0x2316c5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2316aa
leaq 0x1791e4(%rip), %rax    # 0x3aa88c
jmp 0x2316c5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2316be
leaq 0x6846e(%rip), %rax     # 0x299b2a
jmp 0x2316c5
leaq 0x83090(%rip), %rax     # 0x2b4755
movq %rax, 0x572e9c(%rip)    # 0x7a4568
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23171f
leaq 0x25fce1(%rip), %rax    # 0x4913fe
jmp 0x23174e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231733
leaq 0x17ada3(%rip), %rax    # 0x3ac4d4
jmp 0x23174e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231747
leaq 0x683e5(%rip), %rax     # 0x299b2a
jmp 0x23174e
leaq 0x84e66(%rip), %rax     # 0x2b65b4
movq %rax, 0x572e1b(%rip)    # 0x7a4570
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2317a8
leaq 0x26330e(%rip), %rax    # 0x494ab4
jmp 0x2317d7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2317bc
leaq 0x17d1c4(%rip), %rax    # 0x3ae97e
jmp 0x2317d7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2317d0
leaq 0x6835c(%rip), %rax     # 0x299b2a
jmp 0x2317d7
leaq 0x8765f(%rip), %rax     # 0x2b8e36
movq %rax, 0x572d9a(%rip)    # 0x7a4578
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231831
leaq 0x26d0c2(%rip), %rax    # 0x49e8f1
jmp 0x231860
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231845
leaq 0x186259(%rip), %rax    # 0x3b7a9c
jmp 0x231860
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231859
leaq 0x69151(%rip), %rax     # 0x29a9a8
jmp 0x231860
leaq 0x90b9e(%rip), %rax     # 0x2c23fe
movq %rax, 0x572d19(%rip)    # 0x7a4580
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2318ba
leaq 0x27049c(%rip), %rax    # 0x4a1d54
jmp 0x2318e9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2318ce
leaq 0x189284(%rip), %rax    # 0x3bab50
jmp 0x2318e9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2318e2
leaq 0x690c8(%rip), %rax     # 0x29a9a8
jmp 0x2318e9
leaq 0x941f2(%rip), %rax     # 0x2c5adb
movq %rax, 0x572c98(%rip)    # 0x7a4588
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231943
leaq 0x2732af(%rip), %rax    # 0x4a4bf0
jmp 0x231972
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231957
leaq 0x18c036(%rip), %rax    # 0x3bd98b
jmp 0x231972
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23196b
leaq 0x6903f(%rip), %rax     # 0x29a9a8
jmp 0x231972
leaq 0x9743e(%rip), %rax     # 0x2c8db0
movq %rax, 0x572c17(%rip)    # 0x7a4590
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2319cc
leaq 0x2760e8(%rip), %rax    # 0x4a7ab2
jmp 0x2319fb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2319e0
leaq 0x18ee8b(%rip), %rax    # 0x3c0869
jmp 0x2319fb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2319f4
leaq 0x68fb6(%rip), %rax     # 0x29a9a8
jmp 0x2319fb
leaq 0x9a84e(%rip), %rax     # 0x2cc249
movq %rax, 0x572b96(%rip)    # 0x7a4598
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231a55
leaq 0x28aaea(%rip), %rax    # 0x4bc53d
jmp 0x231a84
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231a69
leaq 0x1a0572(%rip), %rax    # 0x3d1fd9
jmp 0x231a84
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231a7d
leaq 0x680af(%rip), %rax     # 0x299b2a
jmp 0x231a84
leaq 0xae034(%rip), %rax     # 0x2dfab8
movq %rax, 0x572b15(%rip)    # 0x7a45a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231ade
leaq 0x28da6f(%rip), %rax    # 0x4bf54b
jmp 0x231b0d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231af2
leaq 0x1a32f7(%rip), %rax    # 0x3d4de7
jmp 0x231b0d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231b06
leaq 0x68026(%rip), %rax     # 0x299b2a
jmp 0x231b0d
leaq 0xb141b(%rip), %rax     # 0x2e2f28
movq %rax, 0x572a94(%rip)    # 0x7a45a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x231b67
leaq 0x290596(%rip), %rax    # 0x4c20fb
jmp 0x231b96
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231b7b
leaq 0x1a5e8a(%rip), %rax    # 0x3d7a03
jmp 0x231b96
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231b8f
leaq 0x67f9d(%rip), %rax     # 0x299b2a
jmp 0x231b96
leaq 0xb4362(%rip), %rax     # 0x2e5ef8
movq %rax, 0x572a13(%rip)    # 0x7a45b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax