LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_profile_16_pointer = parasail_sw_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_profile_16_pointer = parasail_sw_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_profile_16_pointer = parasail_sw_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_profile_16_pointer = parasail_sw_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_profile_16_pointer = parasail_sw_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_rowcol_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dee06
leaq 0x97c3f3(%rip), %rax    # 0xb5b1f0
movq %rax, 0xc490cc(%rip)    # 0xe27ed0
jmp 0x1dee4c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dee22
leaq 0x5cb597(%rip), %rax    # 0x7aa3b0
movq %rax, 0xc490b0(%rip)    # 0xe27ed0
jmp 0x1dee4a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dee3e
leaq 0x2e5b1b(%rip), %rax    # 0x4c4950
movq %rax, 0xc49094(%rip)    # 0xe27ed0
jmp 0x1dee48
movq $0x0, -0x8(%rbp)
jmp 0x1dee6b
jmp 0x1dee4a
jmp 0x1dee4c
movq 0xc4907d(%rip), %rax    # 0xe27ed0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_profile_8_pointer = parasail_sw_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_profile_8_pointer = parasail_sw_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_profile_8_pointer = parasail_sw_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_profile_8_pointer = parasail_sw_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_profile_8_pointer = parasail_sw_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_rowcol_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1deeb6
leaq 0x98ed43(%rip), %rax    # 0xb6dbf0
movq %rax, 0xc49024(%rip)    # 0xe27ed8
jmp 0x1deefc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1deed2
leaq 0x5d8137(%rip), %rax    # 0x7b7000
movq %rax, 0xc49008(%rip)    # 0xe27ed8
jmp 0x1deefa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1deeee
leaq 0x2f1b1b(%rip), %rax    # 0x4d0a00
movq %rax, 0xc48fec(%rip)    # 0xe27ed8
jmp 0x1deef8
movq $0x0, -0x8(%rbp)
jmp 0x1def1b
jmp 0x1deefa
jmp 0x1deefc
movq 0xc48fd5(%rip), %rax    # 0xe27ed8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_profile_64_pointer = parasail_sw_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_profile_64_pointer = parasail_sw_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_profile_64_pointer = parasail_sw_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_profile_64_pointer = parasail_sw_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_profile_64_pointer = parasail_sw_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_rowcol_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1def66
leaq 0x9e8953(%rip), %rax    # 0xbc78b0
movq %rax, 0xc48f7c(%rip)    # 0xe27ee0
jmp 0x1defac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1def82
leaq 0x614e77(%rip), %rax    # 0x7f3df0
movq %rax, 0xc48f60(%rip)    # 0xe27ee0
jmp 0x1defaa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1def9e
leaq 0x32cf1b(%rip), %rax    # 0x50beb0
movq %rax, 0xc48f44(%rip)    # 0xe27ee0
jmp 0x1defa8
movq $0x0, -0x8(%rbp)
jmp 0x1defcb
jmp 0x1defaa
jmp 0x1defac
movq 0xc48f2d(%rip), %rax    # 0xe27ee0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_profile_32_pointer = parasail_sw_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_profile_32_pointer = parasail_sw_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_profile_32_pointer = parasail_sw_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_profile_32_pointer = parasail_sw_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_profile_32_pointer = parasail_sw_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_rowcol_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df016
leaq 0x9f4583(%rip), %rax    # 0xbd3590
movq %rax, 0xc48ed4(%rip)    # 0xe27ee8
jmp 0x1df05c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df032
leaq 0x61ec87(%rip), %rax    # 0x7fdcb0
movq %rax, 0xc48eb8(%rip)    # 0xe27ee8
jmp 0x1df05a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df04e
leaq 0x33677b(%rip), %rax    # 0x5157c0
movq %rax, 0xc48e9c(%rip)    # 0xe27ee8
jmp 0x1df058
movq $0x0, -0x8(%rbp)
jmp 0x1df07b
jmp 0x1df05a
jmp 0x1df05c
movq 0xc48e85(%rip), %rax    # 0xe27ee8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_profile_16_pointer = parasail_sw_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_profile_16_pointer = parasail_sw_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_profile_16_pointer = parasail_sw_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_profile_16_pointer = parasail_sw_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_profile_16_pointer = parasail_sw_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_rowcol_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df0c6
leaq 0xa01223(%rip), %rax    # 0xbe02e0
movq %rax, 0xc48e2c(%rip)    # 0xe27ef0
jmp 0x1df10c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df0e2
leaq 0x629237(%rip), %rax    # 0x808310
movq %rax, 0xc48e10(%rip)    # 0xe27ef0
jmp 0x1df10a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df0fe
leaq 0x34054b(%rip), %rax    # 0x51f640
movq %rax, 0xc48df4(%rip)    # 0xe27ef0
jmp 0x1df108
movq $0x0, -0x8(%rbp)
jmp 0x1df12b
jmp 0x1df10a
jmp 0x1df10c
movq 0xc48ddd(%rip), %rax    # 0xe27ef0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_rowcol_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df176
leaq 0xa0ffd3(%rip), %rax    # 0xbef140
movq %rax, 0xc48d84(%rip)    # 0xe27ef8
jmp 0x1df1bc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df192
leaq 0x634817(%rip), %rax    # 0x8139a0
movq %rax, 0xc48d68(%rip)    # 0xe27ef8
jmp 0x1df1ba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df1ae
leaq 0x34b32b(%rip), %rax    # 0x52a4d0
movq %rax, 0xc48d4c(%rip)    # 0xe27ef8
jmp 0x1df1b8
movq $0x0, -0x8(%rbp)
jmp 0x1df1db
jmp 0x1df1ba
jmp 0x1df1bc
movq 0xc48d35(%rip), %rax    # 0xe27ef8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df226
leaq 0xa1ad13(%rip), %rax    # 0xbf9f30
movq %rax, 0xc48cdc(%rip)    # 0xe27f00
jmp 0x1df26c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df242
leaq 0x63cff7(%rip), %rax    # 0x81c230
movq %rax, 0xc48cc0(%rip)    # 0xe27f00
jmp 0x1df26a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df25e
leaq 0x35374b(%rip), %rax    # 0x5329a0
movq %rax, 0xc48ca4(%rip)    # 0xe27f00
jmp 0x1df268
movq $0x0, -0x8(%rbp)
jmp 0x1df28b
jmp 0x1df26a
jmp 0x1df26c
movq 0xc48c8d(%rip), %rax    # 0xe27f00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df2d6
leaq 0xa23363(%rip), %rax    # 0xc02630
movq %rax, 0xc48c34(%rip)    # 0xe27f08
jmp 0x1df31c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df2f2
leaq 0x6438f7(%rip), %rax    # 0x822be0
movq %rax, 0xc48c18(%rip)    # 0xe27f08
jmp 0x1df31a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df30e
leaq 0x35a13b(%rip), %rax    # 0x539440
movq %rax, 0xc48bfc(%rip)    # 0xe27f08
jmp 0x1df318
movq $0x0, -0x8(%rbp)
jmp 0x1df33b
jmp 0x1df31a
jmp 0x1df31c
movq 0xc48be5(%rip), %rax    # 0xe27f08
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df386
leaq 0xa2d473(%rip), %rax    # 0xc0c7f0
movq %rax, 0xc48b8c(%rip)    # 0xe27f10
jmp 0x1df3cc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df3a2
leaq 0x64acd7(%rip), %rax    # 0x82a070
movq %rax, 0xc48b70(%rip)    # 0xe27f10
jmp 0x1df3ca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df3be
leaq 0x3616cb(%rip), %rax    # 0x540a80
movq %rax, 0xc48b54(%rip)    # 0xe27f10
jmp 0x1df3c8
movq $0x0, -0x8(%rbp)
jmp 0x1df3eb
jmp 0x1df3ca
jmp 0x1df3cc
movq 0xc48b3d(%rip), %rax    # 0xe27f10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df436
leaq 0xa3a7d3(%rip), %rax    # 0xc19c00
movq %rax, 0xc48ae4(%rip)    # 0xe27f18
jmp 0x1df47c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df452
leaq 0x653387(%rip), %rax    # 0x8327d0
movq %rax, 0xc48ac8(%rip)    # 0xe27f18
jmp 0x1df47a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df46e
leaq 0x36a1cb(%rip), %rax    # 0x549630
movq %rax, 0xc48aac(%rip)    # 0xe27f18
jmp 0x1df478
movq $0x0, -0x8(%rbp)
jmp 0x1df49b
jmp 0x1df47a
jmp 0x1df47c
movq 0xc48a95(%rip), %rax    # 0xe27f18
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df4e6
leaq 0xa83f53(%rip), %rax    # 0xc63430
movq %rax, 0xc48a3c(%rip)    # 0xe27f20
jmp 0x1df52c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df502
leaq 0x681d87(%rip), %rax    # 0x861280
movq %rax, 0xc48a20(%rip)    # 0xe27f20
jmp 0x1df52a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df51e
leaq 0x3995cb(%rip), %rax    # 0x578ae0
movq %rax, 0xc48a04(%rip)    # 0xe27f20
jmp 0x1df528
movq $0x0, -0x8(%rbp)
jmp 0x1df54b
jmp 0x1df52a
jmp 0x1df52c
movq 0xc489ed(%rip), %rax    # 0xe27f20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df596
leaq 0xa8dd63(%rip), %rax    # 0xc6d2f0
movq %rax, 0xc48994(%rip)    # 0xe27f28
jmp 0x1df5dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df5b2
leaq 0x689d17(%rip), %rax    # 0x8692c0
movq %rax, 0xc48978(%rip)    # 0xe27f28
jmp 0x1df5da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df5ce
leaq 0x3a150b(%rip), %rax    # 0x580ad0
movq %rax, 0xc4895c(%rip)    # 0xe27f28
jmp 0x1df5d8
movq $0x0, -0x8(%rbp)
jmp 0x1df5fb
jmp 0x1df5da
jmp 0x1df5dc
movq 0xc48945(%rip), %rax    # 0xe27f28
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df646
leaq 0xa995e3(%rip), %rax    # 0xc78c20
movq %rax, 0xc488ec(%rip)    # 0xe27f30
jmp 0x1df68c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df662
leaq 0x692987(%rip), %rax    # 0x871fe0
movq %rax, 0xc488d0(%rip)    # 0xe27f30
jmp 0x1df68a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df67e
leaq 0x3aa14b(%rip), %rax    # 0x5897c0
movq %rax, 0xc488b4(%rip)    # 0xe27f30
jmp 0x1df688
movq $0x0, -0x8(%rbp)
jmp 0x1df6ab
jmp 0x1df68a
jmp 0x1df68c
movq 0xc4889d(%rip), %rax    # 0xe27f30
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1df6f6
leaq 0xaa7d73(%rip), %rax    # 0xc87460
movq %rax, 0xc48844(%rip)    # 0xe27f38
jmp 0x1df73c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1df712
leaq 0x69ca77(%rip), %rax    # 0x87c180
movq %rax, 0xc48828(%rip)    # 0xe27f38
jmp 0x1df73a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1df72e
leaq 0x3b44fb(%rip), %rax    # 0x593c20
movq %rax, 0xc4880c(%rip)    # 0xe27f38
jmp 0x1df738
movq $0x0, -0x8(%rbp)
jmp 0x1df75b
jmp 0x1df73a
jmp 0x1df73c
movq 0xc487f5(%rip), %rax    # 0xe27f38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_scan_64_pointer = parasail_sg_qb_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e1fee
leaq 0x6a103b(%rip), %rax    # 0x883020
movq %rax, 0xc45f54(%rip)    # 0xe27f40
jmp 0x1e2038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e200a
leaq 0x3b810f(%rip), %rax    # 0x59a110
movq %rax, 0xc45f38(%rip)    # 0xe27f40
jmp 0x1e2036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2026
leaq 0xde1b3(%rip), %rax     # 0x2c01d0
movq %rax, 0xc45f1c(%rip)    # 0xe27f40
jmp 0x1e2034
leaq 0xb7203(%rip), %rax     # 0x299230
movq %rax, 0xc45f0c(%rip)    # 0xe27f40
jmp 0x1e2036
jmp 0x1e2038
movq 0xc45f01(%rip), %rax    # 0xe27f40
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_scan_32_pointer = parasail_sg_qb_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e20ae
leaq 0x6a745b(%rip), %rax    # 0x889500
movq %rax, 0xc45e9c(%rip)    # 0xe27f48
jmp 0x1e20f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e20ca
leaq 0x3bd2cf(%rip), %rax    # 0x59f390
movq %rax, 0xc45e80(%rip)    # 0xe27f48
jmp 0x1e20f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e20e6
leaq 0xe3553(%rip), %rax     # 0x2c5630
movq %rax, 0xc45e64(%rip)    # 0xe27f48
jmp 0x1e20f4
leaq 0xb7143(%rip), %rax     # 0x299230
movq %rax, 0xc45e54(%rip)    # 0xe27f48
jmp 0x1e20f6
jmp 0x1e20f8
movq 0xc45e49(%rip), %rax    # 0xe27f48
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_scan_16_pointer = parasail_sg_qb_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e216e
leaq 0x6ae6db(%rip), %rax    # 0x890840
movq %rax, 0xc45de4(%rip)    # 0xe27f50
jmp 0x1e21b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e218a
leaq 0x3c298f(%rip), %rax    # 0x5a4b10
movq %rax, 0xc45dc8(%rip)    # 0xe27f50
jmp 0x1e21b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e21a6
leaq 0xe8d53(%rip), %rax     # 0x2caef0
movq %rax, 0xc45dac(%rip)    # 0xe27f50
jmp 0x1e21b4
leaq 0xb7083(%rip), %rax     # 0x299230
movq %rax, 0xc45d9c(%rip)    # 0xe27f50
jmp 0x1e21b6
jmp 0x1e21b8
movq 0xc45d91(%rip), %rax    # 0xe27f50
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_scan_8_pointer = parasail_sg_qb_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e222e
leaq 0x6b73eb(%rip), %rax    # 0x899610
movq %rax, 0xc45d2c(%rip)    # 0xe27f58
jmp 0x1e2278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e224a
leaq 0x3c883f(%rip), %rax    # 0x5aaa80
movq %rax, 0xc45d10(%rip)    # 0xe27f58
jmp 0x1e2276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2266
leaq 0xeef23(%rip), %rax     # 0x2d1180
movq %rax, 0xc45cf4(%rip)    # 0xe27f58
jmp 0x1e2274
leaq 0xb6fc3(%rip), %rax     # 0x299230
movq %rax, 0xc45ce4(%rip)    # 0xe27f58
jmp 0x1e2276
jmp 0x1e2278
movq 0xc45cd9(%rip), %rax    # 0xe27f58
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_striped_64_pointer = parasail_sg_qb_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e22ee
leaq 0x6ec52b(%rip), %rax    # 0x8ce810
movq %rax, 0xc45c74(%rip)    # 0xe27f60
jmp 0x1e2338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e230a
leaq 0x3eb84f(%rip), %rax    # 0x5cdb50
movq %rax, 0xc45c58(%rip)    # 0xe27f60
jmp 0x1e2336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2326
leaq 0x112d43(%rip), %rax    # 0x2f5060
movq %rax, 0xc45c3c(%rip)    # 0xe27f60
jmp 0x1e2334
leaq 0xb4fa3(%rip), %rax     # 0x2972d0
movq %rax, 0xc45c2c(%rip)    # 0xe27f60
jmp 0x1e2336
jmp 0x1e2338
movq 0xc45c21(%rip), %rax    # 0xe27f60
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_striped_32_pointer = parasail_sg_qb_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e23ae
leaq 0x6f1a8b(%rip), %rax    # 0x8d3e30
movq %rax, 0xc45bbc(%rip)    # 0xe27f68
jmp 0x1e23f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e23ca
leaq 0x3f01df(%rip), %rax    # 0x5d25a0
movq %rax, 0xc45ba0(%rip)    # 0xe27f68
jmp 0x1e23f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e23e6
leaq 0x117853(%rip), %rax    # 0x2f9c30
movq %rax, 0xc45b84(%rip)    # 0xe27f68
jmp 0x1e23f4
leaq 0xb4ee3(%rip), %rax     # 0x2972d0
movq %rax, 0xc45b74(%rip)    # 0xe27f68
jmp 0x1e23f6
jmp 0x1e23f8
movq 0xc45b69(%rip), %rax    # 0xe27f68
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)