LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_profile_16_pointer = parasail_sg_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_profile_16_pointer = parasail_sg_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_profile_16_pointer = parasail_sg_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_profile_16_pointer = parasail_sg_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_profile_16_pointer = parasail_sg_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6046
leaq 0x984ed3(%rip), %rax    # 0xb5af10
movq %rax, 0xc51a2c(%rip)    # 0xe27a70
jmp 0x1d608c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6062
leaq 0x5d4077(%rip), %rax    # 0x7aa0d0
movq %rax, 0xc51a10(%rip)    # 0xe27a70
jmp 0x1d608a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d607e
leaq 0x2ee5fb(%rip), %rax    # 0x4c4670
movq %rax, 0xc519f4(%rip)    # 0xe27a70
jmp 0x1d6088
movq $0x0, -0x8(%rbp)
jmp 0x1d60ab
jmp 0x1d608a
jmp 0x1d608c
movq 0xc519dd(%rip), %rax    # 0xe27a70
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_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_profile_8_pointer = parasail_sg_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_profile_8_pointer = parasail_sg_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_profile_8_pointer = parasail_sg_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_profile_8_pointer = parasail_sg_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_profile_8_pointer = parasail_sg_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d60f6
leaq 0x997823(%rip), %rax    # 0xb6d910
movq %rax, 0xc51984(%rip)    # 0xe27a78
jmp 0x1d613c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6112
leaq 0x5e0c17(%rip), %rax    # 0x7b6d20
movq %rax, 0xc51968(%rip)    # 0xe27a78
jmp 0x1d613a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d612e
leaq 0x2fa5fb(%rip), %rax    # 0x4d0720
movq %rax, 0xc5194c(%rip)    # 0xe27a78
jmp 0x1d6138
movq $0x0, -0x8(%rbp)
jmp 0x1d615b
jmp 0x1d613a
jmp 0x1d613c
movq 0xc51935(%rip), %rax    # 0xe27a78
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_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_profile_64_pointer = parasail_sg_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_profile_64_pointer = parasail_sg_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_profile_64_pointer = parasail_sg_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_profile_64_pointer = parasail_sg_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_profile_64_pointer = parasail_sg_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d61a6
leaq 0x9f1433(%rip), %rax    # 0xbc75d0
movq %rax, 0xc518dc(%rip)    # 0xe27a80
jmp 0x1d61ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d61c2
leaq 0x61d957(%rip), %rax    # 0x7f3b10
movq %rax, 0xc518c0(%rip)    # 0xe27a80
jmp 0x1d61ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d61de
leaq 0x3359fb(%rip), %rax    # 0x50bbd0
movq %rax, 0xc518a4(%rip)    # 0xe27a80
jmp 0x1d61e8
movq $0x0, -0x8(%rbp)
jmp 0x1d620b
jmp 0x1d61ea
jmp 0x1d61ec
movq 0xc5188d(%rip), %rax    # 0xe27a80
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_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_profile_32_pointer = parasail_sg_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6256
leaq 0x9fd063(%rip), %rax    # 0xbd32b0
movq %rax, 0xc51834(%rip)    # 0xe27a88
jmp 0x1d629c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6272
leaq 0x627767(%rip), %rax    # 0x7fd9d0
movq %rax, 0xc51818(%rip)    # 0xe27a88
jmp 0x1d629a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d628e
leaq 0x33f25b(%rip), %rax    # 0x5154e0
movq %rax, 0xc517fc(%rip)    # 0xe27a88
jmp 0x1d6298
movq $0x0, -0x8(%rbp)
jmp 0x1d62bb
jmp 0x1d629a
jmp 0x1d629c
movq 0xc517e5(%rip), %rax    # 0xe27a88
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_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_profile_16_pointer = parasail_sg_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6306
leaq 0xa09d03(%rip), %rax    # 0xbe0000
movq %rax, 0xc5178c(%rip)    # 0xe27a90
jmp 0x1d634c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6322
leaq 0x631d17(%rip), %rax    # 0x808030
movq %rax, 0xc51770(%rip)    # 0xe27a90
jmp 0x1d634a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d633e
leaq 0x34902b(%rip), %rax    # 0x51f360
movq %rax, 0xc51754(%rip)    # 0xe27a90
jmp 0x1d6348
movq $0x0, -0x8(%rbp)
jmp 0x1d636b
jmp 0x1d634a
jmp 0x1d634c
movq 0xc5173d(%rip), %rax    # 0xe27a90
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_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_profile_8_pointer = parasail_sg_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d63b6
leaq 0xa18ab3(%rip), %rax    # 0xbeee60
movq %rax, 0xc516e4(%rip)    # 0xe27a98
jmp 0x1d63fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d63d2
leaq 0x63d2f7(%rip), %rax    # 0x8136c0
movq %rax, 0xc516c8(%rip)    # 0xe27a98
jmp 0x1d63fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d63ee
leaq 0x353e0b(%rip), %rax    # 0x52a1f0
movq %rax, 0xc516ac(%rip)    # 0xe27a98
jmp 0x1d63f8
movq $0x0, -0x8(%rbp)
jmp 0x1d641b
jmp 0x1d63fa
jmp 0x1d63fc
movq 0xc51695(%rip), %rax    # 0xe27a98
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_dispatch.c
// Function: parasail_sg_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_trace_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_64_pointer = parasail_sg_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6466
leaq 0xa23823(%rip), %rax    # 0xbf9c80
movq %rax, 0xc5163c(%rip)    # 0xe27aa0
jmp 0x1d64ac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6482
leaq 0x645b07(%rip), %rax    # 0x81bf80
movq %rax, 0xc51620(%rip)    # 0xe27aa0
jmp 0x1d64aa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d649e
leaq 0x35c25b(%rip), %rax    # 0x5326f0
movq %rax, 0xc51604(%rip)    # 0xe27aa0
jmp 0x1d64a8
movq $0x0, -0x8(%rbp)
jmp 0x1d64cb
jmp 0x1d64aa
jmp 0x1d64ac
movq 0xc515ed(%rip), %rax    # 0xe27aa0
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_dispatch.c
// Function: parasail_sg_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_trace_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_32_pointer = parasail_sg_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6516
leaq 0xa2be73(%rip), %rax    # 0xc02380
movq %rax, 0xc51594(%rip)    # 0xe27aa8
jmp 0x1d655c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6532
leaq 0x64c407(%rip), %rax    # 0x822930
movq %rax, 0xc51578(%rip)    # 0xe27aa8
jmp 0x1d655a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d654e
leaq 0x362c4b(%rip), %rax    # 0x539190
movq %rax, 0xc5155c(%rip)    # 0xe27aa8
jmp 0x1d6558
movq $0x0, -0x8(%rbp)
jmp 0x1d657b
jmp 0x1d655a
jmp 0x1d655c
movq 0xc51545(%rip), %rax    # 0xe27aa8
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_dispatch.c
// Function: parasail_sg_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_trace_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_16_pointer = parasail_sg_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d65c6
leaq 0xa35f83(%rip), %rax    # 0xc0c540
movq %rax, 0xc514ec(%rip)    # 0xe27ab0
jmp 0x1d660c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d65e2
leaq 0x6537e7(%rip), %rax    # 0x829dc0
movq %rax, 0xc514d0(%rip)    # 0xe27ab0
jmp 0x1d660a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d65fe
leaq 0x36a1db(%rip), %rax    # 0x5407d0
movq %rax, 0xc514b4(%rip)    # 0xe27ab0
jmp 0x1d6608
movq $0x0, -0x8(%rbp)
jmp 0x1d662b
jmp 0x1d660a
jmp 0x1d660c
movq 0xc5149d(%rip), %rax    # 0xe27ab0
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_dispatch.c
// Function: parasail_sg_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_trace_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_profile_8_pointer = parasail_sg_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6676
leaq 0xa432e3(%rip), %rax    # 0xc19950
movq %rax, 0xc51444(%rip)    # 0xe27ab8
jmp 0x1d66bc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6692
leaq 0x65be97(%rip), %rax    # 0x832520
movq %rax, 0xc51428(%rip)    # 0xe27ab8
jmp 0x1d66ba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d66ae
leaq 0x372cdb(%rip), %rax    # 0x549380
movq %rax, 0xc5140c(%rip)    # 0xe27ab8
jmp 0x1d66b8
movq $0x0, -0x8(%rbp)
jmp 0x1d66db
jmp 0x1d66ba
jmp 0x1d66bc
movq 0xc513f5(%rip), %rax    # 0xe27ab8
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_dispatch.c
// Function: parasail_sg_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_trace_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_64_pointer = parasail_sg_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6726
leaq 0xa8ca63(%rip), %rax    # 0xc63180
movq %rax, 0xc5139c(%rip)    # 0xe27ac0
jmp 0x1d676c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6742
leaq 0x68a897(%rip), %rax    # 0x860fd0
movq %rax, 0xc51380(%rip)    # 0xe27ac0
jmp 0x1d676a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d675e
leaq 0x3a20db(%rip), %rax    # 0x578830
movq %rax, 0xc51364(%rip)    # 0xe27ac0
jmp 0x1d6768
movq $0x0, -0x8(%rbp)
jmp 0x1d678b
jmp 0x1d676a
jmp 0x1d676c
movq 0xc5134d(%rip), %rax    # 0xe27ac0
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_dispatch.c
// Function: parasail_sg_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_trace_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d67d6
leaq 0xa96873(%rip), %rax    # 0xc6d040
movq %rax, 0xc512f4(%rip)    # 0xe27ac8
jmp 0x1d681c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d67f2
leaq 0x692827(%rip), %rax    # 0x869010
movq %rax, 0xc512d8(%rip)    # 0xe27ac8
jmp 0x1d681a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d680e
leaq 0x3aa01b(%rip), %rax    # 0x580820
movq %rax, 0xc512bc(%rip)    # 0xe27ac8
jmp 0x1d6818
movq $0x0, -0x8(%rbp)
jmp 0x1d683b
jmp 0x1d681a
jmp 0x1d681c
movq 0xc512a5(%rip), %rax    # 0xe27ac8
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_dispatch.c
// Function: parasail_sg_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_trace_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6886
leaq 0xaa20f3(%rip), %rax    # 0xc78970
movq %rax, 0xc5124c(%rip)    # 0xe27ad0
jmp 0x1d68cc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d68a2
leaq 0x69b497(%rip), %rax    # 0x871d30
movq %rax, 0xc51230(%rip)    # 0xe27ad0
jmp 0x1d68ca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d68be
leaq 0x3b2c5b(%rip), %rax    # 0x589510
movq %rax, 0xc51214(%rip)    # 0xe27ad0
jmp 0x1d68c8
movq $0x0, -0x8(%rbp)
jmp 0x1d68eb
jmp 0x1d68ca
jmp 0x1d68cc
movq 0xc511fd(%rip), %rax    # 0xe27ad0
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_dispatch.c
// Function: parasail_sg_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_trace_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d6936
leaq 0xab0883(%rip), %rax    # 0xc871b0
movq %rax, 0xc511a4(%rip)    # 0xe27ad8
jmp 0x1d697c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d6952
leaq 0x6a5587(%rip), %rax    # 0x87bed0
movq %rax, 0xc51188(%rip)    # 0xe27ad8
jmp 0x1d697a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d696e
leaq 0x3bd00b(%rip), %rax    # 0x593970
movq %rax, 0xc5116c(%rip)    # 0xe27ad8
jmp 0x1d6978
movq $0x0, -0x8(%rbp)
jmp 0x1d699b
jmp 0x1d697a
jmp 0x1d697c
movq 0xc51155(%rip), %rax    # 0xe27ad8
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_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_64_pointer = parasail_sw_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d922e
leaq 0x6aa6eb(%rip), %rax    # 0x883910
movq %rax, 0xc4e8b4(%rip)    # 0xe27ae0
jmp 0x1d9278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d924a
leaq 0x3c17bf(%rip), %rax    # 0x59aa00
movq %rax, 0xc4e898(%rip)    # 0xe27ae0
jmp 0x1d9276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9266
leaq 0xe7863(%rip), %rax     # 0x2c0ac0
movq %rax, 0xc4e87c(%rip)    # 0xe27ae0
jmp 0x1d9274
leaq 0xc0493(%rip), %rax     # 0x299700
movq %rax, 0xc4e86c(%rip)    # 0xe27ae0
jmp 0x1d9276
jmp 0x1d9278
movq 0xc4e861(%rip), %rax    # 0xe27ae0
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/sw_dispatch.c
// Function: parasail_sw_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_32_pointer = parasail_sw_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d92ee
leaq 0x6b0b0b(%rip), %rax    # 0x889df0
movq %rax, 0xc4e7fc(%rip)    # 0xe27ae8
jmp 0x1d9338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d930a
leaq 0x3c697f(%rip), %rax    # 0x59fc80
movq %rax, 0xc4e7e0(%rip)    # 0xe27ae8
jmp 0x1d9336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9326
leaq 0xecc03(%rip), %rax     # 0x2c5f20
movq %rax, 0xc4e7c4(%rip)    # 0xe27ae8
jmp 0x1d9334
leaq 0xc03d3(%rip), %rax     # 0x299700
movq %rax, 0xc4e7b4(%rip)    # 0xe27ae8
jmp 0x1d9336
jmp 0x1d9338
movq 0xc4e7a9(%rip), %rax    # 0xe27ae8
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/sw_dispatch.c
// Function: parasail_sw_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_16_pointer = parasail_sw_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d93ae
leaq 0x6b7d8b(%rip), %rax    # 0x891130
movq %rax, 0xc4e744(%rip)    # 0xe27af0
jmp 0x1d93f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d93ca
leaq 0x3cc03f(%rip), %rax    # 0x5a5400
movq %rax, 0xc4e728(%rip)    # 0xe27af0
jmp 0x1d93f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d93e6
leaq 0xf2403(%rip), %rax     # 0x2cb7e0
movq %rax, 0xc4e70c(%rip)    # 0xe27af0
jmp 0x1d93f4
leaq 0xc0313(%rip), %rax     # 0x299700
movq %rax, 0xc4e6fc(%rip)    # 0xe27af0
jmp 0x1d93f6
jmp 0x1d93f8
movq 0xc4e6f1(%rip), %rax    # 0xe27af0
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/sw_dispatch.c
// Function: parasail_sw_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_8_pointer = parasail_sw_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1d946e
leaq 0x6c0a9b(%rip), %rax    # 0x899f00
movq %rax, 0xc4e68c(%rip)    # 0xe27af8
jmp 0x1d94b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d948a
leaq 0x3d1eef(%rip), %rax    # 0x5ab370
movq %rax, 0xc4e670(%rip)    # 0xe27af8
jmp 0x1d94b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d94a6
leaq 0xf85d3(%rip), %rax     # 0x2d1a70
movq %rax, 0xc4e654(%rip)    # 0xe27af8
jmp 0x1d94b4
leaq 0xc0253(%rip), %rax     # 0x299700
movq %rax, 0xc4e644(%rip)    # 0xe27af8
jmp 0x1d94b6
jmp 0x1d94b8
movq 0xc4e639(%rip), %rax    # 0xe27af8
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/sw_dispatch.c
// Function: parasail_sw_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_64_pointer = parasail_sw_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d952e
leaq 0x6f5bdb(%rip), %rax    # 0x8cf100
movq %rax, 0xc4e5d4(%rip)    # 0xe27b00
jmp 0x1d9578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d954a
leaq 0x3f4eff(%rip), %rax    # 0x5ce440
movq %rax, 0xc4e5b8(%rip)    # 0xe27b00
jmp 0x1d9576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9566
leaq 0x11c3f3(%rip), %rax    # 0x2f5950
movq %rax, 0xc4e59c(%rip)    # 0xe27b00
jmp 0x1d9574
leaq 0xbe233(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e58c(%rip)    # 0xe27b00
jmp 0x1d9576
jmp 0x1d9578
movq 0xc4e581(%rip), %rax    # 0xe27b00
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/sw_dispatch.c
// Function: parasail_sw_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_32_pointer = parasail_sw_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1d95ee
leaq 0x6fb13b(%rip), %rax    # 0x8d4720
movq %rax, 0xc4e51c(%rip)    # 0xe27b08
jmp 0x1d9638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d960a
leaq 0x3f988f(%rip), %rax    # 0x5d2e90
movq %rax, 0xc4e500(%rip)    # 0xe27b08
jmp 0x1d9636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d9626
leaq 0x120f03(%rip), %rax    # 0x2fa520
movq %rax, 0xc4e4e4(%rip)    # 0xe27b08
jmp 0x1d9634
leaq 0xbe173(%rip), %rax     # 0x2977a0
movq %rax, 0xc4e4d4(%rip)    # 0xe27b08
jmp 0x1d9636
jmp 0x1d9638
movq 0xc4e4c9(%rip), %rax    # 0xe27b08
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)