LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_rowcol_scan_profile_32_pointer = parasail_sg_de_stats_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_profile_32_pointer = parasail_sg_de_stats_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_profile_32_pointer = parasail_sg_de_stats_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_profile_32_pointer = parasail_sg_de_stats_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_profile_32_pointer = parasail_sg_de_stats_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_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 0x5c8fdb
testl %eax, %eax
je 0x231ba4
leaq 0x343f71(%rip), %rax    # 0x575b13
jmp 0x231bca
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231bb8
leaq 0x235cf4(%rip), %rax    # 0x4678aa
jmp 0x231bca
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231be9
leaq 0x13fad8(%rip), %rax    # 0x3716a2
movq %rax, 0x5a88d7(%rip)    # 0x7da4a8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_de_stats_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_de_stats_rowcol_scan_profile_16_pointer = parasail_sg_de_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_profile_16_pointer = parasail_sg_de_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_profile_16_pointer = parasail_sg_de_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_profile_16_pointer = parasail_sg_de_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_profile_16_pointer = parasail_sg_de_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x231c1e
leaq 0x3488f2(%rip), %rax    # 0x57a50e
jmp 0x231c44
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231c32
leaq 0x239a26(%rip), %rax    # 0x46b656
jmp 0x231c44
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231c63
leaq 0x143fe9(%rip), %rax    # 0x375c2d
movq %rax, 0x5a8865(%rip)    # 0x7da4b0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_de_stats_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_de_stats_rowcol_scan_profile_8_pointer = parasail_sg_de_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_profile_8_pointer = parasail_sg_de_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_profile_8_pointer = parasail_sg_de_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_profile_8_pointer = parasail_sg_de_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_profile_8_pointer = parasail_sg_de_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x231c98
leaq 0x34dceb(%rip), %rax    # 0x57f981
jmp 0x231cbe
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231cac
leaq 0x23e45b(%rip), %rax    # 0x470105
jmp 0x231cbe
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231cdd
leaq 0x14960b(%rip), %rax    # 0x37b2c9
movq %rax, 0x5a87f3(%rip)    # 0x7da4b8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_de_stats_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_de_stats_rowcol_striped_profile_64_pointer = parasail_sg_de_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_profile_64_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_profile_64_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_profile_64_pointer = parasail_sg_de_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_profile_64_pointer = parasail_sg_de_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x231d12
leaq 0x3669cc(%rip), %rax    # 0x5986dc
jmp 0x231d38
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231d26
leaq 0x253396(%rip), %rax    # 0x4850ba
jmp 0x231d38
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231d57
leaq 0x161265(%rip), %rax    # 0x392f9d
movq %rax, 0x5a8781(%rip)    # 0x7da4c0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_de_stats_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_de_stats_rowcol_striped_profile_32_pointer = parasail_sg_de_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_profile_32_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_profile_32_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_profile_32_pointer = parasail_sg_de_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_profile_32_pointer = parasail_sg_de_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x231d8c
leaq 0x369d9a(%rip), %rax    # 0x59bb24
jmp 0x231db2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231da0
leaq 0x2565f1(%rip), %rax    # 0x48838f
jmp 0x231db2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231dd1
leaq 0x164f98(%rip), %rax    # 0x396d4a
movq %rax, 0x5a870f(%rip)    # 0x7da4c8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_de_stats_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_de_stats_rowcol_striped_profile_16_pointer = parasail_sg_de_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_profile_16_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_profile_16_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_profile_16_pointer = parasail_sg_de_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_profile_16_pointer = parasail_sg_de_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x231e06
leaq 0x36e505(%rip), %rax    # 0x5a0309
jmp 0x231e2c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231e1a
leaq 0x259ef3(%rip), %rax    # 0x48bd0b
jmp 0x231e2c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231e4b
leaq 0x168f33(%rip), %rax    # 0x39ad5f
movq %rax, 0x5a869d(%rip)    # 0x7da4d0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_de_stats_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_de_stats_rowcol_striped_profile_8_pointer = parasail_sg_de_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_profile_8_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_profile_8_pointer = parasail_sg_de_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_profile_8_pointer = parasail_sg_de_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_profile_8_pointer = parasail_sg_de_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x231e80
leaq 0x373c96(%rip), %rax    # 0x5a5b14
jmp 0x231ea6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231e94
leaq 0x25e60e(%rip), %rax    # 0x4904a0
jmp 0x231ea6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231ec5
leaq 0x16dfdb(%rip), %rax    # 0x39fe81
movq %rax, 0x5a862b(%rip)    # 0x7da4d8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_scan_profile_64_pointer = parasail_sg_de_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_profile_64_pointer = parasail_sg_de_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_profile_64_pointer = parasail_sg_de_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_profile_64_pointer = parasail_sg_de_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_profile_64_pointer = parasail_sg_de_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x231efa
leaq 0x37645c(%rip), %rax    # 0x5a8354
jmp 0x231f20
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231f0e
leaq 0x26108b(%rip), %rax    # 0x492f97
jmp 0x231f20
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231f3f
leaq 0x1711a4(%rip), %rax    # 0x3a30c4
movq %rax, 0x5a85b9(%rip)    # 0x7da4e0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_scan_profile_32_pointer = parasail_sg_de_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_profile_32_pointer = parasail_sg_de_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_profile_32_pointer = parasail_sg_de_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_profile_32_pointer = parasail_sg_de_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_profile_32_pointer = parasail_sg_de_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x231f74
leaq 0x3780ac(%rip), %rax    # 0x5aa01e
jmp 0x231f9a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x231f88
leaq 0x262ca7(%rip), %rax    # 0x494c2d
jmp 0x231f9a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x231fb9
leaq 0x173349(%rip), %rax    # 0x3a52e3
movq %rax, 0x5a8547(%rip)    # 0x7da4e8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x231fee
leaq 0x37a725(%rip), %rax    # 0x5ac711
jmp 0x232014
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232002
leaq 0x264b4d(%rip), %rax    # 0x496b4d
jmp 0x232014
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x232033
leaq 0x175698(%rip), %rax    # 0x3a76ac
movq %rax, 0x5a84d5(%rip)    # 0x7da4f0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x232068
leaq 0x37db4c(%rip), %rax    # 0x5afbb2
jmp 0x23208e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23207c
leaq 0x266dff(%rip), %rax    # 0x498e79
jmp 0x23208e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2320ad
leaq 0x178203(%rip), %rax    # 0x3aa291
movq %rax, 0x5a8463(%rip)    # 0x7da4f8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2320e2
leaq 0x38db74(%rip), %rax    # 0x5bfc54
jmp 0x232108
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2320f6
leaq 0x272cd0(%rip), %rax    # 0x4a4dc4
jmp 0x232108
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x232127
leaq 0x18602a(%rip), %rax    # 0x3b8132
movq %rax, 0x5a83f1(%rip)    # 0x7da500
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x23215c
leaq 0x38fc6b(%rip), %rax    # 0x5c1dc5
jmp 0x232182
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232170
leaq 0x274e79(%rip), %rax    # 0x4a6fe7
jmp 0x232182
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x2321a1
leaq 0x188919(%rip), %rax    # 0x3baa9b
movq %rax, 0x5a837f(%rip)    # 0x7da508
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x2321d6
leaq 0x392849(%rip), %rax    # 0x5c4a1d
jmp 0x2321fc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2321ea
leaq 0x2772e1(%rip), %rax    # 0x4a94c9
jmp 0x2321fc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23221b
leaq 0x18b245(%rip), %rax    # 0x3bd441
movq %rax, 0x5a830d(%rip)    # 0x7da510
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x232250
leaq 0x396231(%rip), %rax    # 0x5c847f
jmp 0x232276
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232264
leaq 0x279b58(%rip), %rax    # 0x4abdba
jmp 0x232276
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x232295
leaq 0x18e3de(%rip), %rax    # 0x3c0654
movq %rax, 0x5a829b(%rip)    # 0x7da518
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x2327bd
leaq 0x27afdd(%rip), %rax    # 0x4ad798
jmp 0x2327ec
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2327d1
leaq 0x18fb10(%rip), %rax    # 0x3c22df
jmp 0x2327ec
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2327e5
leaq 0x69c11(%rip), %rax     # 0x29c3f4
jmp 0x2327ec
leaq 0x7cd80(%rip), %rax     # 0x2af56c
movq %rax, 0x5a7d2d(%rip)    # 0x7da520
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x232846
leaq 0x27c854(%rip), %rax    # 0x4af098
jmp 0x232875
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23285a
leaq 0x191454(%rip), %rax    # 0x3c3cac
jmp 0x232875
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23286e
leaq 0x69b88(%rip), %rax     # 0x29c3f4
jmp 0x232875
leaq 0x7eb9f(%rip), %rax     # 0x2b1414
movq %rax, 0x5a7cac(%rip)    # 0x7da528
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x2328cf
leaq 0x27ebc2(%rip), %rax    # 0x4b148f
jmp 0x2328fe
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2328e3
leaq 0x192faa(%rip), %rax    # 0x3c588b
jmp 0x2328fe
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2328f7
leaq 0x69aff(%rip), %rax     # 0x29c3f4
jmp 0x2328fe
leaq 0x80bed(%rip), %rax     # 0x2b34eb
movq %rax, 0x5a7c2b(%rip)    # 0x7da530
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x232958
leaq 0x281d23(%rip), %rax    # 0x4b4679
jmp 0x232987
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23296c
leaq 0x194f26(%rip), %rax    # 0x3c7890
jmp 0x232987
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232980
leaq 0x69a76(%rip), %rax     # 0x29c3f4
jmp 0x232987
leaq 0x834ee(%rip), %rax     # 0x2b5e75
movq %rax, 0x5a7baa(%rip)    # 0x7da538
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x2329e1
leaq 0x28c878(%rip), %rax    # 0x4bf257
jmp 0x232a10
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2329f5
leaq 0x19ddba(%rip), %rax    # 0x3d07ad
jmp 0x232a10
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232a09
leaq 0x686f1(%rip), %rax     # 0x29b0f8
jmp 0x232a10
leaq 0x8df5f(%rip), %rax     # 0x2c096f
movq %rax, 0x5a7b29(%rip)    # 0x7da540
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x232a6a
leaq 0x28de47(%rip), %rax    # 0x4c08af
jmp 0x232a99
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232a7e
leaq 0x19f45a(%rip), %rax    # 0x3d1ed6
jmp 0x232a99
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232a92
leaq 0x68668(%rip), %rax     # 0x29b0f8
jmp 0x232a99
leaq 0x8fa53(%rip), %rax     # 0x2c24ec
movq %rax, 0x5a7aa8(%rip)    # 0x7da548
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x232af3
leaq 0x28fec5(%rip), %rax    # 0x4c29b6
jmp 0x232b22
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232b07
leaq 0x1a0d3a(%rip), %rax    # 0x3d383f
jmp 0x232b22
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232b1b
leaq 0x685df(%rip), %rax     # 0x29b0f8
jmp 0x232b22
leaq 0x9174b(%rip), %rax     # 0x2c426d
movq %rax, 0x5a7a27(%rip)    # 0x7da550
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