LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_striped_profile_32_pointer = parasail_nw_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_profile_32_pointer = parasail_nw_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_profile_32_pointer = parasail_nw_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_profile_32_pointer = parasail_nw_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_profile_32_pointer = parasail_nw_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_rowcol_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b1828
leaq 0x358d49(%rip), %rax    # 0x50a56f
jmp 0x1b184e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b183c
leaq 0x24f3e9(%rip), %rax    # 0x400c23
jmp 0x1b184e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b186d
leaq 0x1534e5(%rip), %rax    # 0x304d33
movq %rax, 0x589d93(%rip)    # 0x73b5e8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_striped_profile_16_pointer = parasail_nw_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_profile_16_pointer = parasail_nw_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_profile_16_pointer = parasail_nw_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_profile_16_pointer = parasail_nw_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_profile_16_pointer = parasail_nw_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_rowcol_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b18a2
leaq 0x35a853(%rip), %rax    # 0x50c0f3
jmp 0x1b18c8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b18b6
leaq 0x250df3(%rip), %rax    # 0x4026a7
jmp 0x1b18c8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b18e7
leaq 0x155247(%rip), %rax    # 0x306b0f
movq %rax, 0x589d21(%rip)    # 0x73b5f0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_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_nw_rowcol_striped_profile_8_pointer = parasail_nw_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_profile_8_pointer = parasail_nw_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_profile_8_pointer = parasail_nw_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_profile_8_pointer = parasail_nw_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_profile_8_pointer = parasail_nw_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_rowcol_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b191c
leaq 0x35c82d(%rip), %rax    # 0x50e147
jmp 0x1b1942
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1930
leaq 0x252a61(%rip), %rax    # 0x40438f
jmp 0x1b1942
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1961
leaq 0x156f41(%rip), %rax    # 0x308883
movq %rax, 0x589caf(%rip)    # 0x73b5f8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b1996
leaq 0x35eea8(%rip), %rax    # 0x51083c
jmp 0x1b19bc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b19aa
leaq 0x2551c0(%rip), %rax    # 0x406b68
jmp 0x1b19bc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b19db
leaq 0x159214(%rip), %rax    # 0x30abd0
movq %rax, 0x589c3d(%rip)    # 0x73b600
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b1a10
leaq 0x3638ce(%rip), %rax    # 0x5152dc
jmp 0x1b1a36
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1a24
leaq 0x259612(%rip), %rax    # 0x40b034
jmp 0x1b1a36
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1a55
leaq 0x15e4b2(%rip), %rax    # 0x30fee8
movq %rax, 0x589bcb(%rip)    # 0x73b608
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1a8a
leaq 0x3673b4(%rip), %rax    # 0x518e3c
jmp 0x1b1ab0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1a9e
leaq 0x25cf68(%rip), %rax    # 0x40ea04
jmp 0x1b1ab0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1acf
leaq 0x162470(%rip), %rax    # 0x313f20
movq %rax, 0x589b59(%rip)    # 0x73b610
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1b04
leaq 0x36b0d6(%rip), %rax    # 0x51cbd8
jmp 0x1b1b2a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1b18
leaq 0x260a92(%rip), %rax    # 0x4125a8
jmp 0x1b1b2a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1b49
leaq 0x166316(%rip), %rax    # 0x317e40
movq %rax, 0x589ae7(%rip)    # 0x73b618
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1b7e
leaq 0x384aec(%rip), %rax    # 0x536668
jmp 0x1b1ba4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1b92
leaq 0x2761f0(%rip), %rax    # 0x427d80
jmp 0x1b1ba4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1bc3
leaq 0x17e430(%rip), %rax    # 0x32ffd4
movq %rax, 0x589a75(%rip)    # 0x73b620
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1bf8
leaq 0x388c4e(%rip), %rax    # 0x53a844
jmp 0x1b1c1e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1c0c
leaq 0x27a122(%rip), %rax    # 0x42bd2c
jmp 0x1b1c1e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1c3d
leaq 0x183156(%rip), %rax    # 0x334d74
movq %rax, 0x589a03(%rip)    # 0x73b628
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1c72
leaq 0x38c398(%rip), %rax    # 0x53e008
jmp 0x1b1c98
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1c86
leaq 0x27d760(%rip), %rax    # 0x42f3e4
jmp 0x1b1c98
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1cb7
leaq 0x186eb4(%rip), %rax    # 0x338b4c
movq %rax, 0x589991(%rip)    # 0x73b630
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1cec
leaq 0x38ff3e(%rip), %rax    # 0x541c28
jmp 0x1b1d12
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1d00
leaq 0x2810d2(%rip), %rax    # 0x432dd0
jmp 0x1b1d12
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1d31
leaq 0x18aa7e(%rip), %rax    # 0x33c790
movq %rax, 0x58991f(%rip)    # 0x73b638
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1d66
leaq 0x393fb7(%rip), %rax    # 0x545d1b
jmp 0x1b1d8c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1d7a
leaq 0x284c43(%rip), %rax    # 0x4369bb
jmp 0x1b1d8c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1dab
leaq 0x18ec07(%rip), %rax    # 0x340993
movq %rax, 0x5898ad(%rip)    # 0x73b640
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1de0
leaq 0x3963e1(%rip), %rax    # 0x5481bf
jmp 0x1b1e06
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1df4
leaq 0x286f99(%rip), %rax    # 0x438d8b
jmp 0x1b1e06
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1e25
leaq 0x191801(%rip), %rax    # 0x343607
movq %rax, 0x58983b(%rip)    # 0x73b648
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1e5a
leaq 0x398123(%rip), %rax    # 0x549f7b
jmp 0x1b1e80
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1e6e
leaq 0x288ce3(%rip), %rax    # 0x43ab4f
jmp 0x1b1e80
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1e9f
leaq 0x193887(%rip), %rax    # 0x345707
movq %rax, 0x5897c9(%rip)    # 0x73b650
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1ed4
leaq 0x399eb9(%rip), %rax    # 0x54bd8b
jmp 0x1b1efa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1ee8
leaq 0x28ab41(%rip), %rax    # 0x43ca27
jmp 0x1b1efa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1f19
leaq 0x195771(%rip), %rax    # 0x34766b
movq %rax, 0x589757(%rip)    # 0x73b658
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1f4e
leaq 0x3ab55f(%rip), %rax    # 0x55d4ab
jmp 0x1b1f74
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1f62
leaq 0x297b43(%rip), %rax    # 0x449aa3
jmp 0x1b1f74
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b1f93
leaq 0x1a3c4f(%rip), %rax    # 0x355bc3
movq %rax, 0x5896e5(%rip)    # 0x73b660
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b1fc8
leaq 0x3ae459(%rip), %rax    # 0x56041f
jmp 0x1b1fee
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b1fdc
leaq 0x29a985(%rip), %rax    # 0x44c95f
jmp 0x1b1fee
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b200d
leaq 0x1a7689(%rip), %rax    # 0x359677
movq %rax, 0x589673(%rip)    # 0x73b668
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b2042
leaq 0x3b084f(%rip), %rax    # 0x56288f
jmp 0x1b2068
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2056
leaq 0x29cd97(%rip), %rax    # 0x44edeb
jmp 0x1b2068
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b2087
leaq 0x1a9e83(%rip), %rax    # 0x35beeb
movq %rax, 0x589601(%rip)    # 0x73b670
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1b20bc
leaq 0x3b2d51(%rip), %rax    # 0x564e0b
jmp 0x1b20e2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b20d0
leaq 0x29f2c1(%rip), %rax    # 0x45138f
jmp 0x1b20e2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b2101
leaq 0x1ac435(%rip), %rax    # 0x35e517
movq %rax, 0x58958f(%rip)    # 0x73b678
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_64_dispatcher
parasail_result_t* parasail_sg_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_scan_64_pointer = parasail_sg_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x5672cf
testl %eax, %eax
je 0x1b2629
leaq 0x2a2865(%rip), %rax    # 0x454e8c
jmp 0x1b2658
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b263d
leaq 0x1afb74(%rip), %rax    # 0x3621af
jmp 0x1b2658
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2651
leaq 0x8b37d(%rip), %rax     # 0x23d9cc
jmp 0x1b2658
leaq 0x9eae6(%rip), %rax     # 0x25113e
movq %rax, 0x589021(%rip)    # 0x73b680
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_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_32_dispatcher
parasail_result_t* parasail_sg_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_scan_32_pointer = parasail_sg_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x5672cf
testl %eax, %eax
je 0x1b26b2
leaq 0x2a4451(%rip), %rax    # 0x456b01
jmp 0x1b26e1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b26c6
leaq 0x1b1680(%rip), %rax    # 0x363d44
jmp 0x1b26e1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b26da
leaq 0x8b2f4(%rip), %rax     # 0x23d9cc
jmp 0x1b26e1
leaq 0xa0a6c(%rip), %rax     # 0x25314d
movq %rax, 0x588fa0(%rip)    # 0x73b688
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_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_16_dispatcher
parasail_result_t* parasail_sg_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_scan_16_pointer = parasail_sg_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x5672cf
testl %eax, %eax
je 0x1b273b
leaq 0x2a5f44(%rip), %rax    # 0x45867d
jmp 0x1b276a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b274f
leaq 0x1b3182(%rip), %rax    # 0x3658cf
jmp 0x1b276a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2763
leaq 0x8b26b(%rip), %rax     # 0x23d9cc
jmp 0x1b276a
leaq 0xa26df(%rip), %rax     # 0x254e49
movq %rax, 0x588f1f(%rip)    # 0x73b690
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