LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_trace_striped_profile_32_pointer = parasail_sg_qe_db_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_striped_profile_32_pointer = parasail_sg_qe_db_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_striped_profile_32_pointer = parasail_sg_qe_db_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_striped_profile_32_pointer = parasail_sg_qe_db_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_striped_profile_32_pointer = parasail_sg_qe_db_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x226396
leaq 0xa46b93(%rip), %rax    # 0xc6cf20
movq %rax, 0xc03e94(%rip)    # 0xe2a228
jmp 0x2263dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2263b2
leaq 0x642b47(%rip), %rax    # 0x868ef0
movq %rax, 0xc03e78(%rip)    # 0xe2a228
jmp 0x2263da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2263ce
leaq 0x35a33b(%rip), %rax    # 0x580700
movq %rax, 0xc03e5c(%rip)    # 0xe2a228
jmp 0x2263d8
movq $0x0, -0x8(%rbp)
jmp 0x2263fb
jmp 0x2263da
jmp 0x2263dc
movq 0xc03e45(%rip), %rax    # 0xe2a228
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_db_dispatch.c
// Function: parasail_sg_qe_db_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_trace_striped_profile_16_pointer = parasail_sg_qe_db_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_striped_profile_16_pointer = parasail_sg_qe_db_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_striped_profile_16_pointer = parasail_sg_qe_db_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_striped_profile_16_pointer = parasail_sg_qe_db_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_striped_profile_16_pointer = parasail_sg_qe_db_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x226446
leaq 0xa52413(%rip), %rax    # 0xc78850
movq %rax, 0xc03dec(%rip)    # 0xe2a230
jmp 0x22648c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x226462
leaq 0x64b7b7(%rip), %rax    # 0x871c10
movq %rax, 0xc03dd0(%rip)    # 0xe2a230
jmp 0x22648a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22647e
leaq 0x362f7b(%rip), %rax    # 0x5893f0
movq %rax, 0xc03db4(%rip)    # 0xe2a230
jmp 0x226488
movq $0x0, -0x8(%rbp)
jmp 0x2264ab
jmp 0x22648a
jmp 0x22648c
movq 0xc03d9d(%rip), %rax    # 0xe2a230
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_db_dispatch.c
// Function: parasail_sg_qe_db_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_trace_striped_profile_8_pointer = parasail_sg_qe_db_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_striped_profile_8_pointer = parasail_sg_qe_db_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_striped_profile_8_pointer = parasail_sg_qe_db_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_striped_profile_8_pointer = parasail_sg_qe_db_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_striped_profile_8_pointer = parasail_sg_qe_db_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x2264f6
leaq 0xa60ba3(%rip), %rax    # 0xc87090
movq %rax, 0xc03d44(%rip)    # 0xe2a238
jmp 0x22653c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x226512
leaq 0x6558a7(%rip), %rax    # 0x87bdb0
movq %rax, 0xc03d28(%rip)    # 0xe2a238
jmp 0x22653a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x22652e
leaq 0x36d32b(%rip), %rax    # 0x593850
movq %rax, 0xc03d0c(%rip)    # 0xe2a238
jmp 0x226538
movq $0x0, -0x8(%rbp)
jmp 0x22655b
jmp 0x22653a
jmp 0x22653c
movq 0xc03cf5(%rip), %rax    # 0xe2a238
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_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_db_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_scan_64_pointer = parasail_sg_qb_db_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_scan_64_pointer = parasail_sg_qb_db_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_scan_64_pointer = parasail_sg_qb_db_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_scan_64_pointer = parasail_sg_qb_db_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_scan_64_pointer = parasail_sg_qb_db_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_scan_64_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_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 0x228dee
leaq 0x65a5bb(%rip), %rax    # 0x8833a0
movq %rax, 0xc01454(%rip)    # 0xe2a240
jmp 0x228e38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x228e0a
leaq 0x37168f(%rip), %rax    # 0x59a490
movq %rax, 0xc01438(%rip)    # 0xe2a240
jmp 0x228e36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x228e26
leaq 0x97733(%rip), %rax     # 0x2c0550
movq %rax, 0xc0141c(%rip)    # 0xe2a240
jmp 0x228e34
leaq 0x70783(%rip), %rax     # 0x2995b0
movq %rax, 0xc0140c(%rip)    # 0xe2a240
jmp 0x228e36
jmp 0x228e38
movq 0xc01401(%rip), %rax    # 0xe2a240
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_db_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_scan_32_pointer = parasail_sg_qb_db_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_scan_32_pointer = parasail_sg_qb_db_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_scan_32_pointer = parasail_sg_qb_db_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_scan_32_pointer = parasail_sg_qb_db_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_scan_32_pointer = parasail_sg_qb_db_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_scan_32_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_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 0x228eae
leaq 0x6609db(%rip), %rax    # 0x889880
movq %rax, 0xc0139c(%rip)    # 0xe2a248
jmp 0x228ef8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x228eca
leaq 0x37684f(%rip), %rax    # 0x59f710
movq %rax, 0xc01380(%rip)    # 0xe2a248
jmp 0x228ef6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x228ee6
leaq 0x9cad3(%rip), %rax     # 0x2c59b0
movq %rax, 0xc01364(%rip)    # 0xe2a248
jmp 0x228ef4
leaq 0x706c3(%rip), %rax     # 0x2995b0
movq %rax, 0xc01354(%rip)    # 0xe2a248
jmp 0x228ef6
jmp 0x228ef8
movq 0xc01349(%rip), %rax    # 0xe2a248
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_db_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_scan_16_pointer = parasail_sg_qb_db_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_scan_16_pointer = parasail_sg_qb_db_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_scan_16_pointer = parasail_sg_qb_db_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_scan_16_pointer = parasail_sg_qb_db_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_scan_16_pointer = parasail_sg_qb_db_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_scan_16_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_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 0x228f6e
leaq 0x667c5b(%rip), %rax    # 0x890bc0
movq %rax, 0xc012e4(%rip)    # 0xe2a250
jmp 0x228fb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x228f8a
leaq 0x37bf0f(%rip), %rax    # 0x5a4e90
movq %rax, 0xc012c8(%rip)    # 0xe2a250
jmp 0x228fb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x228fa6
leaq 0xa22d3(%rip), %rax     # 0x2cb270
movq %rax, 0xc012ac(%rip)    # 0xe2a250
jmp 0x228fb4
leaq 0x70603(%rip), %rax     # 0x2995b0
movq %rax, 0xc0129c(%rip)    # 0xe2a250
jmp 0x228fb6
jmp 0x228fb8
movq 0xc01291(%rip), %rax    # 0xe2a250
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_db_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_scan_8_pointer = parasail_sg_qb_db_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_scan_8_pointer = parasail_sg_qb_db_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_scan_8_pointer = parasail_sg_qb_db_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_scan_8_pointer = parasail_sg_qb_db_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_scan_8_pointer = parasail_sg_qb_db_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_scan_8_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_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 0x22902e
leaq 0x67096b(%rip), %rax    # 0x899990
movq %rax, 0xc0122c(%rip)    # 0xe2a258
jmp 0x229078
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22904a
leaq 0x381dbf(%rip), %rax    # 0x5aae00
movq %rax, 0xc01210(%rip)    # 0xe2a258
jmp 0x229076
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229066
leaq 0xa84a3(%rip), %rax     # 0x2d1500
movq %rax, 0xc011f4(%rip)    # 0xe2a258
jmp 0x229074
leaq 0x70543(%rip), %rax     # 0x2995b0
movq %rax, 0xc011e4(%rip)    # 0xe2a258
jmp 0x229076
jmp 0x229078
movq 0xc011d9(%rip), %rax    # 0xe2a258
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_db_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_striped_64_pointer = parasail_sg_qb_db_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_64_pointer = parasail_sg_qb_db_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_64_pointer = parasail_sg_qb_db_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_64_pointer = parasail_sg_qb_db_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_64_pointer = parasail_sg_qb_db_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_striped_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x2290ee
leaq 0x6a5aab(%rip), %rax    # 0x8ceb90
movq %rax, 0xc01174(%rip)    # 0xe2a260
jmp 0x229138
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22910a
leaq 0x3a4dcf(%rip), %rax    # 0x5cded0
movq %rax, 0xc01158(%rip)    # 0xe2a260
jmp 0x229136
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229126
leaq 0xcc2c3(%rip), %rax     # 0x2f53e0
movq %rax, 0xc0113c(%rip)    # 0xe2a260
jmp 0x229134
leaq 0x6e523(%rip), %rax     # 0x297650
movq %rax, 0xc0112c(%rip)    # 0xe2a260
jmp 0x229136
jmp 0x229138
movq 0xc01121(%rip), %rax    # 0xe2a260
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_db_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x2291ae
leaq 0x6ab00b(%rip), %rax    # 0x8d41b0
movq %rax, 0xc010bc(%rip)    # 0xe2a268
jmp 0x2291f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2291ca
leaq 0x3a975f(%rip), %rax    # 0x5d2920
movq %rax, 0xc010a0(%rip)    # 0xe2a268
jmp 0x2291f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2291e6
leaq 0xd0dd3(%rip), %rax     # 0x2f9fb0
movq %rax, 0xc01084(%rip)    # 0xe2a268
jmp 0x2291f4
leaq 0x6e463(%rip), %rax     # 0x297650
movq %rax, 0xc01074(%rip)    # 0xe2a268
jmp 0x2291f6
jmp 0x2291f8
movq 0xc01069(%rip), %rax    # 0xe2a268
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x22926e
leaq 0x6b0ecb(%rip), %rax    # 0x8da130
movq %rax, 0xc01004(%rip)    # 0xe2a270
jmp 0x2292b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22928a
leaq 0x3ae4ef(%rip), %rax    # 0x5d7770
movq %rax, 0xc00fe8(%rip)    # 0xe2a270
jmp 0x2292b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2292a6
leaq 0xd5c23(%rip), %rax     # 0x2feec0
movq %rax, 0xc00fcc(%rip)    # 0xe2a270
jmp 0x2292b4
leaq 0x6e3a3(%rip), %rax     # 0x297650
movq %rax, 0xc00fbc(%rip)    # 0xe2a270
jmp 0x2292b6
jmp 0x2292b8
movq 0xc00fb1(%rip), %rax    # 0xe2a270
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x22932e
leaq 0x6b804b(%rip), %rax    # 0x8e1370
movq %rax, 0xc00f4c(%rip)    # 0xe2a278
jmp 0x229378
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22934a
leaq 0x3b3acf(%rip), %rax    # 0x5dce10
movq %rax, 0xc00f30(%rip)    # 0xe2a278
jmp 0x229376
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229366
leaq 0xdb503(%rip), %rax     # 0x304860
movq %rax, 0xc00f14(%rip)    # 0xe2a278
jmp 0x229374
leaq 0x6e2e3(%rip), %rax     # 0x297650
movq %rax, 0xc00f04(%rip)    # 0xe2a278
jmp 0x229376
jmp 0x229378
movq 0xc00ef9(%rip), %rax    # 0xe2a278
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x2293ee
leaq 0x67882b(%rip), %rax    # 0x8a1c10
movq %rax, 0xc00e94(%rip)    # 0xe2a280
jmp 0x229438
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22940a
leaq 0x38769f(%rip), %rax    # 0x5b0aa0
movq %rax, 0xc00e78(%rip)    # 0xe2a280
jmp 0x229436
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229426
leaq 0xadec3(%rip), %rax     # 0x2d72e0
movq %rax, 0xc00e5c(%rip)    # 0xe2a280
jmp 0x229434
leaq 0x6e223(%rip), %rax     # 0x297650
movq %rax, 0xc00e4c(%rip)    # 0xe2a280
jmp 0x229436
jmp 0x229438
movq 0xc00e41(%rip), %rax    # 0xe2a280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x2294ae
leaq 0x6808db(%rip), %rax    # 0x8a9d80
movq %rax, 0xc00ddc(%rip)    # 0xe2a288
jmp 0x2294f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2294ca
leaq 0x38d25f(%rip), %rax    # 0x5b6720
movq %rax, 0xc00dc0(%rip)    # 0xe2a288
jmp 0x2294f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2294e6
leaq 0xb3ca3(%rip), %rax     # 0x2dd180
movq %rax, 0xc00da4(%rip)    # 0xe2a288
jmp 0x2294f4
leaq 0x6e163(%rip), %rax     # 0x297650
movq %rax, 0xc00d94(%rip)    # 0xe2a288
jmp 0x2294f6
jmp 0x2294f8
movq 0xc00d89(%rip), %rax    # 0xe2a288
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x22956e
leaq 0x68b7cb(%rip), %rax    # 0x8b4d30
movq %rax, 0xc00d24(%rip)    # 0xe2a290
jmp 0x2295b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22958a
leaq 0x39438f(%rip), %rax    # 0x5bd910
movq %rax, 0xc00d08(%rip)    # 0xe2a290
jmp 0x2295b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2295a6
leaq 0xbafb3(%rip), %rax     # 0x2e4550
movq %rax, 0xc00cec(%rip)    # 0xe2a290
jmp 0x2295b4
leaq 0x6e0a3(%rip), %rax     # 0x297650
movq %rax, 0xc00cdc(%rip)    # 0xe2a290
jmp 0x2295b6
jmp 0x2295b8
movq 0xc00cd1(%rip), %rax    # 0xe2a290
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_db_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_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_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 0x22962e
leaq 0x69bebb(%rip), %rax    # 0x8c54e0
movq %rax, 0xc00c6c(%rip)    # 0xe2a298
jmp 0x229678
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22964a
leaq 0x39ddaf(%rip), %rax    # 0x5c73f0
movq %rax, 0xc00c50(%rip)    # 0xe2a298
jmp 0x229676
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229666
leaq 0xc4fe3(%rip), %rax     # 0x2ee640
movq %rax, 0xc00c34(%rip)    # 0xe2a298
jmp 0x229674
leaq 0x6dfe3(%rip), %rax     # 0x297650
movq %rax, 0xc00c24(%rip)    # 0xe2a298
jmp 0x229676
jmp 0x229678
movq 0xc00c19(%rip), %rax    # 0xe2a298
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_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 0x2296ee
leaq 0x6c2e8b(%rip), %rax    # 0x8ec570
movq %rax, 0xc00bb4(%rip)    # 0xe2a2a0
jmp 0x229738
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22970a
leaq 0x3bde0f(%rip), %rax    # 0x5e7510
movq %rax, 0xc00b98(%rip)    # 0xe2a2a0
jmp 0x229736
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229726
leaq 0xe3953(%rip), %rax     # 0x30d070
movq %rax, 0xc00b7c(%rip)    # 0xe2a2a0
jmp 0x229734
leaq 0x6fe83(%rip), %rax     # 0x2995b0
movq %rax, 0xc00b6c(%rip)    # 0xe2a2a0
jmp 0x229736
jmp 0x229738
movq 0xc00b61(%rip), %rax    # 0xe2a2a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_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 0x2297ae
leaq 0x6d007b(%rip), %rax    # 0x8f9820
movq %rax, 0xc00afc(%rip)    # 0xe2a2a8
jmp 0x2297f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2297ca
leaq 0x3c879f(%rip), %rax    # 0x5f1f60
movq %rax, 0xc00ae0(%rip)    # 0xe2a2a8
jmp 0x2297f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2297e6
leaq 0xed583(%rip), %rax     # 0x316d60
movq %rax, 0xc00ac4(%rip)    # 0xe2a2a8
jmp 0x2297f4
leaq 0x6fdc3(%rip), %rax     # 0x2995b0
movq %rax, 0xc00ab4(%rip)    # 0xe2a2a8
jmp 0x2297f6
jmp 0x2297f8
movq 0xc00aa9(%rip), %rax    # 0xe2a2a8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_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 0x22986e
leaq 0x6de82b(%rip), %rax    # 0x908090
movq %rax, 0xc00a44(%rip)    # 0xe2a2b0
jmp 0x2298b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22988a
leaq 0x3d380f(%rip), %rax    # 0x5fd090
movq %rax, 0xc00a28(%rip)    # 0xe2a2b0
jmp 0x2298b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2298a6
leaq 0xf7823(%rip), %rax     # 0x3210c0
movq %rax, 0xc00a0c(%rip)    # 0xe2a2b0
jmp 0x2298b4
leaq 0x6fd03(%rip), %rax     # 0x2995b0
movq %rax, 0xc009fc(%rip)    # 0xe2a2b0
jmp 0x2298b6
jmp 0x2298b8
movq 0xc009f1(%rip), %rax    # 0xe2a2b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_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 0x22992e
leaq 0x6ef75b(%rip), %rax    # 0x919080
movq %rax, 0xc0098c(%rip)    # 0xe2a2b8
jmp 0x229978
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x22994a
leaq 0x3df33f(%rip), %rax    # 0x608c80
movq %rax, 0xc00970(%rip)    # 0xe2a2b8
jmp 0x229976
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229966
leaq 0x102793(%rip), %rax    # 0x32c0f0
movq %rax, 0xc00954(%rip)    # 0xe2a2b8
jmp 0x229974
leaq 0x6fc43(%rip), %rax     # 0x2995b0
movq %rax, 0xc00944(%rip)    # 0xe2a2b8
jmp 0x229976
jmp 0x229978
movq 0xc00939(%rip), %rax    # 0xe2a2b8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_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 0x2299ee
leaq 0x7403cb(%rip), %rax    # 0x969db0
movq %rax, 0xc008d4(%rip)    # 0xe2a2c0
jmp 0x229a38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x229a0a
leaq 0x4174bf(%rip), %rax    # 0x640ec0
movq %rax, 0xc008b8(%rip)    # 0xe2a2c0
jmp 0x229a36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x229a26
leaq 0x138b83(%rip), %rax    # 0x3625a0
movq %rax, 0xc0089c(%rip)    # 0xe2a2c0
jmp 0x229a34
leaq 0x6dc23(%rip), %rax     # 0x297650
movq %rax, 0xc0088c(%rip)    # 0xe2a2c0
jmp 0x229a36
jmp 0x229a38
movq 0xc00881(%rip), %rax    # 0xe2a2c0
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)