LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_scan_profile_64_pointer = parasail_sg_qb_db_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_scan_profile_64_pointer = parasail_sg_qb_db_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_scan_profile_64_pointer = parasail_sg_qb_db_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_scan_profile_64_pointer = parasail_sg_qb_db_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_scan_profile_64_pointer = parasail_sg_qb_db_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22ede6
leaq 0x9cade3(%rip), %rax    # 0xbf9bc0
movq %rax, 0xbfb87c(%rip)    # 0xe2a660
jmp 0x22ee2c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22ee02
leaq 0x5ed0c7(%rip), %rax    # 0x81bec0
movq %rax, 0xbfb860(%rip)    # 0xe2a660
jmp 0x22ee2a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22ee1e
leaq 0x30381b(%rip), %rax    # 0x532630
movq %rax, 0xbfb844(%rip)    # 0xe2a660
jmp 0x22ee28
movq $0x0, -0x8(%rbp)
jmp 0x22ee4b
jmp 0x22ee2a
jmp 0x22ee2c
movq 0xbfb82d(%rip), %rax    # 0xe2a660
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_db_dispatch.c
// Function: parasail_sg_qb_db_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_scan_profile_32_pointer = parasail_sg_qb_db_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_scan_profile_32_pointer = parasail_sg_qb_db_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_scan_profile_32_pointer = parasail_sg_qb_db_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_scan_profile_32_pointer = parasail_sg_qb_db_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_scan_profile_32_pointer = parasail_sg_qb_db_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22ee96
leaq 0x9d3433(%rip), %rax    # 0xc022c0
movq %rax, 0xbfb7d4(%rip)    # 0xe2a668
jmp 0x22eedc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22eeb2
leaq 0x5f39c7(%rip), %rax    # 0x822870
movq %rax, 0xbfb7b8(%rip)    # 0xe2a668
jmp 0x22eeda
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22eece
leaq 0x30a20b(%rip), %rax    # 0x5390d0
movq %rax, 0xbfb79c(%rip)    # 0xe2a668
jmp 0x22eed8
movq $0x0, -0x8(%rbp)
jmp 0x22eefb
jmp 0x22eeda
jmp 0x22eedc
movq 0xbfb785(%rip), %rax    # 0xe2a668
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_db_dispatch.c
// Function: parasail_sg_qb_db_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_scan_profile_16_pointer = parasail_sg_qb_db_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_scan_profile_16_pointer = parasail_sg_qb_db_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_scan_profile_16_pointer = parasail_sg_qb_db_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_scan_profile_16_pointer = parasail_sg_qb_db_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_scan_profile_16_pointer = parasail_sg_qb_db_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22ef46
leaq 0x9dd543(%rip), %rax    # 0xc0c480
movq %rax, 0xbfb72c(%rip)    # 0xe2a670
jmp 0x22ef8c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22ef62
leaq 0x5fada7(%rip), %rax    # 0x829d00
movq %rax, 0xbfb710(%rip)    # 0xe2a670
jmp 0x22ef8a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22ef7e
leaq 0x31179b(%rip), %rax    # 0x540710
movq %rax, 0xbfb6f4(%rip)    # 0xe2a670
jmp 0x22ef88
movq $0x0, -0x8(%rbp)
jmp 0x22efab
jmp 0x22ef8a
jmp 0x22ef8c
movq 0xbfb6dd(%rip), %rax    # 0xe2a670
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_db_dispatch.c
// Function: parasail_sg_qb_db_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_scan_profile_8_pointer = parasail_sg_qb_db_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_scan_profile_8_pointer = parasail_sg_qb_db_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_scan_profile_8_pointer = parasail_sg_qb_db_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_scan_profile_8_pointer = parasail_sg_qb_db_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_scan_profile_8_pointer = parasail_sg_qb_db_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22eff6
leaq 0x9ea8a3(%rip), %rax    # 0xc19890
movq %rax, 0xbfb684(%rip)    # 0xe2a678
jmp 0x22f03c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22f012
leaq 0x603457(%rip), %rax    # 0x832460
movq %rax, 0xbfb668(%rip)    # 0xe2a678
jmp 0x22f03a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22f02e
leaq 0x31a29b(%rip), %rax    # 0x5492c0
movq %rax, 0xbfb64c(%rip)    # 0xe2a678
jmp 0x22f038
movq $0x0, -0x8(%rbp)
jmp 0x22f05b
jmp 0x22f03a
jmp 0x22f03c
movq 0xbfb635(%rip), %rax    # 0xe2a678
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_db_dispatch.c
// Function: parasail_sg_qb_db_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_striped_profile_64_pointer = parasail_sg_qb_db_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_striped_profile_64_pointer = parasail_sg_qb_db_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_striped_profile_64_pointer = parasail_sg_qb_db_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_striped_profile_64_pointer = parasail_sg_qb_db_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_striped_profile_64_pointer = parasail_sg_qb_db_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22f0a6
leaq 0xa34023(%rip), %rax    # 0xc630c0
movq %rax, 0xbfb5dc(%rip)    # 0xe2a680
jmp 0x22f0ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22f0c2
leaq 0x631e57(%rip), %rax    # 0x860f10
movq %rax, 0xbfb5c0(%rip)    # 0xe2a680
jmp 0x22f0ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22f0de
leaq 0x34969b(%rip), %rax    # 0x578770
movq %rax, 0xbfb5a4(%rip)    # 0xe2a680
jmp 0x22f0e8
movq $0x0, -0x8(%rbp)
jmp 0x22f10b
jmp 0x22f0ea
jmp 0x22f0ec
movq 0xbfb58d(%rip), %rax    # 0xe2a680
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_db_dispatch.c
// Function: parasail_sg_qb_db_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_striped_profile_32_pointer = parasail_sg_qb_db_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_striped_profile_32_pointer = parasail_sg_qb_db_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_striped_profile_32_pointer = parasail_sg_qb_db_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_striped_profile_32_pointer = parasail_sg_qb_db_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_striped_profile_32_pointer = parasail_sg_qb_db_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22f156
leaq 0xa3de33(%rip), %rax    # 0xc6cf80
movq %rax, 0xbfb534(%rip)    # 0xe2a688
jmp 0x22f19c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22f172
leaq 0x639de7(%rip), %rax    # 0x868f50
movq %rax, 0xbfb518(%rip)    # 0xe2a688
jmp 0x22f19a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22f18e
leaq 0x3515db(%rip), %rax    # 0x580760
movq %rax, 0xbfb4fc(%rip)    # 0xe2a688
jmp 0x22f198
movq $0x0, -0x8(%rbp)
jmp 0x22f1bb
jmp 0x22f19a
jmp 0x22f19c
movq 0xbfb4e5(%rip), %rax    # 0xe2a688
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_db_dispatch.c
// Function: parasail_sg_qb_db_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_striped_profile_16_pointer = parasail_sg_qb_db_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_striped_profile_16_pointer = parasail_sg_qb_db_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_striped_profile_16_pointer = parasail_sg_qb_db_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_striped_profile_16_pointer = parasail_sg_qb_db_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_striped_profile_16_pointer = parasail_sg_qb_db_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22f206
leaq 0xa496b3(%rip), %rax    # 0xc788b0
movq %rax, 0xbfb48c(%rip)    # 0xe2a690
jmp 0x22f24c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22f222
leaq 0x642a57(%rip), %rax    # 0x871c70
movq %rax, 0xbfb470(%rip)    # 0xe2a690
jmp 0x22f24a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22f23e
leaq 0x35a21b(%rip), %rax    # 0x589450
movq %rax, 0xbfb454(%rip)    # 0xe2a690
jmp 0x22f248
movq $0x0, -0x8(%rbp)
jmp 0x22f26b
jmp 0x22f24a
jmp 0x22f24c
movq 0xbfb43d(%rip), %rax    # 0xe2a690
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_db_dispatch.c
// Function: parasail_sg_qb_db_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_trace_striped_profile_8_pointer = parasail_sg_qb_db_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_trace_striped_profile_8_pointer = parasail_sg_qb_db_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_trace_striped_profile_8_pointer = parasail_sg_qb_db_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_trace_striped_profile_8_pointer = parasail_sg_qb_db_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_trace_striped_profile_8_pointer = parasail_sg_qb_db_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_db_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 0x22f2b6
leaq 0xa57e43(%rip), %rax    # 0xc870f0
movq %rax, 0xbfb3e4(%rip)    # 0xe2a698
jmp 0x22f2fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22f2d2
leaq 0x64cb47(%rip), %rax    # 0x87be10
movq %rax, 0xbfb3c8(%rip)    # 0xe2a698
jmp 0x22f2fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22f2ee
leaq 0x3645cb(%rip), %rax    # 0x5938b0
movq %rax, 0xbfb3ac(%rip)    # 0xe2a698
jmp 0x22f2f8
movq $0x0, -0x8(%rbp)
jmp 0x22f31b
jmp 0x22f2fa
jmp 0x22f2fc
movq 0xbfb395(%rip), %rax    # 0xe2a698
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_scan_64_pointer = parasail_sg_qe_de_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_scan_64_pointer = parasail_sg_qe_de_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_scan_64_pointer = parasail_sg_qe_de_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_scan_64_pointer = parasail_sg_qe_de_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_scan_64_pointer = parasail_sg_qe_de_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_scan_64_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x231bae
leaq 0x65186b(%rip), %rax    # 0x883410
movq %rax, 0xbf8af4(%rip)    # 0xe2a6a0
jmp 0x231bf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x231bca
leaq 0x36893f(%rip), %rax    # 0x59a500
movq %rax, 0xbf8ad8(%rip)    # 0xe2a6a0
jmp 0x231bf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x231be6
leaq 0x8e9e3(%rip), %rax     # 0x2c05c0
movq %rax, 0xbf8abc(%rip)    # 0xe2a6a0
jmp 0x231bf4
leaq 0x67a33(%rip), %rax     # 0x299620
movq %rax, 0xbf8aac(%rip)    # 0xe2a6a0
jmp 0x231bf6
jmp 0x231bf8
movq 0xbf8aa1(%rip), %rax    # 0xe2a6a0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_scan_32_pointer = parasail_sg_qe_de_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_scan_32_pointer = parasail_sg_qe_de_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_scan_32_pointer = parasail_sg_qe_de_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_scan_32_pointer = parasail_sg_qe_de_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_scan_32_pointer = parasail_sg_qe_de_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_scan_32_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x231c6e
leaq 0x657c8b(%rip), %rax    # 0x8898f0
movq %rax, 0xbf8a3c(%rip)    # 0xe2a6a8
jmp 0x231cb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x231c8a
leaq 0x36daff(%rip), %rax    # 0x59f780
movq %rax, 0xbf8a20(%rip)    # 0xe2a6a8
jmp 0x231cb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x231ca6
leaq 0x93d83(%rip), %rax     # 0x2c5a20
movq %rax, 0xbf8a04(%rip)    # 0xe2a6a8
jmp 0x231cb4
leaq 0x67973(%rip), %rax     # 0x299620
movq %rax, 0xbf89f4(%rip)    # 0xe2a6a8
jmp 0x231cb6
jmp 0x231cb8
movq 0xbf89e9(%rip), %rax    # 0xe2a6a8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_scan_16_pointer = parasail_sg_qe_de_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_scan_16_pointer = parasail_sg_qe_de_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_scan_16_pointer = parasail_sg_qe_de_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_scan_16_pointer = parasail_sg_qe_de_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_scan_16_pointer = parasail_sg_qe_de_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_scan_16_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x231d2e
leaq 0x65ef0b(%rip), %rax    # 0x890c30
movq %rax, 0xbf8984(%rip)    # 0xe2a6b0
jmp 0x231d78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x231d4a
leaq 0x3731bf(%rip), %rax    # 0x5a4f00
movq %rax, 0xbf8968(%rip)    # 0xe2a6b0
jmp 0x231d76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x231d66
leaq 0x99583(%rip), %rax     # 0x2cb2e0
movq %rax, 0xbf894c(%rip)    # 0xe2a6b0
jmp 0x231d74
leaq 0x678b3(%rip), %rax     # 0x299620
movq %rax, 0xbf893c(%rip)    # 0xe2a6b0
jmp 0x231d76
jmp 0x231d78
movq 0xbf8931(%rip), %rax    # 0xe2a6b0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_scan_8_pointer = parasail_sg_qe_de_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_scan_8_pointer = parasail_sg_qe_de_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_scan_8_pointer = parasail_sg_qe_de_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_scan_8_pointer = parasail_sg_qe_de_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_scan_8_pointer = parasail_sg_qe_de_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_scan_8_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x231dee
leaq 0x667c1b(%rip), %rax    # 0x899a00
movq %rax, 0xbf88cc(%rip)    # 0xe2a6b8
jmp 0x231e38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x231e0a
leaq 0x37906f(%rip), %rax    # 0x5aae70
movq %rax, 0xbf88b0(%rip)    # 0xe2a6b8
jmp 0x231e36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x231e26
leaq 0x9f753(%rip), %rax     # 0x2d1570
movq %rax, 0xbf8894(%rip)    # 0xe2a6b8
jmp 0x231e34
leaq 0x677f3(%rip), %rax     # 0x299620
movq %rax, 0xbf8884(%rip)    # 0xe2a6b8
jmp 0x231e36
jmp 0x231e38
movq 0xbf8879(%rip), %rax    # 0xe2a6b8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_striped_64_pointer = parasail_sg_qe_de_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_striped_64_pointer = parasail_sg_qe_de_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_striped_64_pointer = parasail_sg_qe_de_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_striped_64_pointer = parasail_sg_qe_de_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_striped_64_pointer = parasail_sg_qe_de_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_striped_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x231eae
leaq 0x69cd5b(%rip), %rax    # 0x8cec00
movq %rax, 0xbf8814(%rip)    # 0xe2a6c0
jmp 0x231ef8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x231eca
leaq 0x39c07f(%rip), %rax    # 0x5cdf40
movq %rax, 0xbf87f8(%rip)    # 0xe2a6c0
jmp 0x231ef6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x231ee6
leaq 0xc3573(%rip), %rax     # 0x2f5450
movq %rax, 0xbf87dc(%rip)    # 0xe2a6c0
jmp 0x231ef4
leaq 0x657d3(%rip), %rax     # 0x2976c0
movq %rax, 0xbf87cc(%rip)    # 0xe2a6c0
jmp 0x231ef6
jmp 0x231ef8
movq 0xbf87c1(%rip), %rax    # 0xe2a6c0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x231f6e
leaq 0x6a22bb(%rip), %rax    # 0x8d4220
movq %rax, 0xbf875c(%rip)    # 0xe2a6c8
jmp 0x231fb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x231f8a
leaq 0x3a0a0f(%rip), %rax    # 0x5d2990
movq %rax, 0xbf8740(%rip)    # 0xe2a6c8
jmp 0x231fb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x231fa6
leaq 0xc8083(%rip), %rax     # 0x2fa020
movq %rax, 0xbf8724(%rip)    # 0xe2a6c8
jmp 0x231fb4
leaq 0x65713(%rip), %rax     # 0x2976c0
movq %rax, 0xbf8714(%rip)    # 0xe2a6c8
jmp 0x231fb6
jmp 0x231fb8
movq 0xbf8709(%rip), %rax    # 0xe2a6c8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_de_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_striped_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 0x23202e
leaq 0x6a817b(%rip), %rax    # 0x8da1a0
movq %rax, 0xbf86a4(%rip)    # 0xe2a6d0
jmp 0x232078
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x23204a
leaq 0x3a579f(%rip), %rax    # 0x5d77e0
movq %rax, 0xbf8688(%rip)    # 0xe2a6d0
jmp 0x232076
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x232066
leaq 0xcced3(%rip), %rax     # 0x2fef30
movq %rax, 0xbf866c(%rip)    # 0xe2a6d0
jmp 0x232074
leaq 0x65653(%rip), %rax     # 0x2976c0
movq %rax, 0xbf865c(%rip)    # 0xe2a6d0
jmp 0x232076
jmp 0x232078
movq 0xbf8651(%rip), %rax    # 0xe2a6d0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_de_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_striped_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 0x2320ee
leaq 0x6af2fb(%rip), %rax    # 0x8e13e0
movq %rax, 0xbf85ec(%rip)    # 0xe2a6d8
jmp 0x232138
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x23210a
leaq 0x3aad7f(%rip), %rax    # 0x5dce80
movq %rax, 0xbf85d0(%rip)    # 0xe2a6d8
jmp 0x232136
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x232126
leaq 0xd27b3(%rip), %rax     # 0x3048d0
movq %rax, 0xbf85b4(%rip)    # 0xe2a6d8
jmp 0x232134
leaq 0x65593(%rip), %rax     # 0x2976c0
movq %rax, 0xbf85a4(%rip)    # 0xe2a6d8
jmp 0x232136
jmp 0x232138
movq 0xbf8599(%rip), %rax    # 0xe2a6d8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_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 0x2321ae
leaq 0x66fadb(%rip), %rax    # 0x8a1c80
movq %rax, 0xbf8534(%rip)    # 0xe2a6e0
jmp 0x2321f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2321ca
leaq 0x37e94f(%rip), %rax    # 0x5b0b10
movq %rax, 0xbf8518(%rip)    # 0xe2a6e0
jmp 0x2321f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2321e6
leaq 0xa5173(%rip), %rax     # 0x2d7350
movq %rax, 0xbf84fc(%rip)    # 0xe2a6e0
jmp 0x2321f4
leaq 0x654d3(%rip), %rax     # 0x2976c0
movq %rax, 0xbf84ec(%rip)    # 0xe2a6e0
jmp 0x2321f6
jmp 0x2321f8
movq 0xbf84e1(%rip), %rax    # 0xe2a6e0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_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 0x23226e
leaq 0x677b8b(%rip), %rax    # 0x8a9df0
movq %rax, 0xbf847c(%rip)    # 0xe2a6e8
jmp 0x2322b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x23228a
leaq 0x38450f(%rip), %rax    # 0x5b6790
movq %rax, 0xbf8460(%rip)    # 0xe2a6e8
jmp 0x2322b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2322a6
leaq 0xaaf53(%rip), %rax     # 0x2dd1f0
movq %rax, 0xbf8444(%rip)    # 0xe2a6e8
jmp 0x2322b4
leaq 0x65413(%rip), %rax     # 0x2976c0
movq %rax, 0xbf8434(%rip)    # 0xe2a6e8
jmp 0x2322b6
jmp 0x2322b8
movq 0xbf8429(%rip), %rax    # 0xe2a6e8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_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 0x23232e
leaq 0x682a7b(%rip), %rax    # 0x8b4da0
movq %rax, 0xbf83c4(%rip)    # 0xe2a6f0
jmp 0x232378
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x23234a
leaq 0x38b63f(%rip), %rax    # 0x5bd980
movq %rax, 0xbf83a8(%rip)    # 0xe2a6f0
jmp 0x232376
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x232366
leaq 0xb2263(%rip), %rax     # 0x2e45c0
movq %rax, 0xbf838c(%rip)    # 0xe2a6f0
jmp 0x232374
leaq 0x65353(%rip), %rax     # 0x2976c0
movq %rax, 0xbf837c(%rip)    # 0xe2a6f0
jmp 0x232376
jmp 0x232378
movq 0xbf8371(%rip), %rax    # 0xe2a6f0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_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 0x2323ee
leaq 0x69316b(%rip), %rax    # 0x8c5550
movq %rax, 0xbf830c(%rip)    # 0xe2a6f8
jmp 0x232438
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x23240a
leaq 0x39505f(%rip), %rax    # 0x5c7460
movq %rax, 0xbf82f0(%rip)    # 0xe2a6f8
jmp 0x232436
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x232426
leaq 0xbc293(%rip), %rax     # 0x2ee6b0
movq %rax, 0xbf82d4(%rip)    # 0xe2a6f8
jmp 0x232434
leaq 0x65293(%rip), %rax     # 0x2976c0
movq %rax, 0xbf82c4(%rip)    # 0xe2a6f8
jmp 0x232436
jmp 0x232438
movq 0xbf82b9(%rip), %rax    # 0xe2a6f8
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)