LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_scan_64_pointer = parasail_sg_qe_db_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_scan_64_pointer = parasail_sg_qe_db_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_scan_64_pointer = parasail_sg_qe_db_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_scan_64_pointer = parasail_sg_qe_db_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_scan_64_pointer = parasail_sg_qe_db_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23e765
leaq 0x369b05(%rip), %rax    # 0x5a8268
jmp 0x23e794
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23e779
leaq 0x254734(%rip), %rax    # 0x492eab
jmp 0x23e794
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23e78d
leaq 0x5dcad(%rip), %rax     # 0x29c438
jmp 0x23e794
leaq 0x164844(%rip), %rax    # 0x3a2fd8
movq %rax, 0x59c885(%rip)    # 0x7db020
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_scan_32_pointer = parasail_sg_qe_db_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_scan_32_pointer = parasail_sg_qe_db_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_scan_32_pointer = parasail_sg_qe_db_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_scan_32_pointer = parasail_sg_qe_db_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_scan_32_pointer = parasail_sg_qe_db_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_trace_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23e7ee
leaq 0x36b746(%rip), %rax    # 0x5a9f32
jmp 0x23e81d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23e802
leaq 0x256341(%rip), %rax    # 0x494b41
jmp 0x23e81d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23e816
leaq 0x5dc24(%rip), %rax     # 0x29c438
jmp 0x23e81d
leaq 0x1669da(%rip), %rax    # 0x3a51f7
movq %rax, 0x59c804(%rip)    # 0x7db028
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_scan_16_pointer = parasail_sg_qe_db_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_scan_16_pointer = parasail_sg_qe_db_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_scan_16_pointer = parasail_sg_qe_db_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_scan_16_pointer = parasail_sg_qe_db_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_scan_16_pointer = parasail_sg_qe_db_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_trace_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23e877
leaq 0x36ddb0(%rip), %rax    # 0x5ac625
jmp 0x23e8a6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23e88b
leaq 0x2581d8(%rip), %rax    # 0x496a61
jmp 0x23e8a6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23e89f
leaq 0x5db9b(%rip), %rax     # 0x29c438
jmp 0x23e8a6
leaq 0x168d1a(%rip), %rax    # 0x3a75c0
movq %rax, 0x59c783(%rip)    # 0x7db030
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_scan_8_pointer = parasail_sg_qe_db_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_scan_8_pointer = parasail_sg_qe_db_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_scan_8_pointer = parasail_sg_qe_db_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_scan_8_pointer = parasail_sg_qe_db_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_scan_8_pointer = parasail_sg_qe_db_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_scan_8_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_trace_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23e900
leaq 0x3711c8(%rip), %rax    # 0x5afac6
jmp 0x23e92f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23e914
leaq 0x25a47b(%rip), %rax    # 0x498d8d
jmp 0x23e92f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23e928
leaq 0x5db12(%rip), %rax     # 0x29c438
jmp 0x23e92f
leaq 0x16b876(%rip), %rax    # 0x3aa1a5
movq %rax, 0x59c702(%rip)    # 0x7db038
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_striped_64_pointer = parasail_sg_qe_db_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_striped_64_pointer = parasail_sg_qe_db_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_striped_64_pointer = parasail_sg_qe_db_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_striped_64_pointer = parasail_sg_qe_db_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_striped_64_pointer = parasail_sg_qe_db_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_striped_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23e989
leaq 0x3811e1(%rip), %rax    # 0x5bfb68
jmp 0x23e9b8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23e99d
leaq 0x26633d(%rip), %rax    # 0x4a4cd8
jmp 0x23e9b8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23e9b1
leaq 0x5c78d(%rip), %rax     # 0x29b13c
jmp 0x23e9b8
leaq 0x17968e(%rip), %rax    # 0x3b8046
movq %rax, 0x59c681(%rip)    # 0x7db040
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_striped_32_pointer = parasail_sg_qe_db_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_striped_32_pointer = parasail_sg_qe_db_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_striped_32_pointer = parasail_sg_qe_db_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_striped_32_pointer = parasail_sg_qe_db_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_striped_32_pointer = parasail_sg_qe_db_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_striped_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ea12
leaq 0x3832c9(%rip), %rax    # 0x5c1cd9
jmp 0x23ea41
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ea26
leaq 0x2684d7(%rip), %rax    # 0x4a6efb
jmp 0x23ea41
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ea3a
leaq 0x5c704(%rip), %rax     # 0x29b13c
jmp 0x23ea41
leaq 0x17bf6e(%rip), %rax    # 0x3ba9af
movq %rax, 0x59c600(%rip)    # 0x7db048
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_striped_16_pointer = parasail_sg_qe_db_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_striped_16_pointer = parasail_sg_qe_db_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_striped_16_pointer = parasail_sg_qe_db_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_striped_16_pointer = parasail_sg_qe_db_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_striped_16_pointer = parasail_sg_qe_db_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_striped_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ea9b
leaq 0x385e98(%rip), %rax    # 0x5c4931
jmp 0x23eaca
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23eaaf
leaq 0x26a930(%rip), %rax    # 0x4a93dd
jmp 0x23eaca
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23eac3
leaq 0x5c67b(%rip), %rax     # 0x29b13c
jmp 0x23eaca
leaq 0x17e88b(%rip), %rax    # 0x3bd355
movq %rax, 0x59c57f(%rip)    # 0x7db050
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_striped_8_pointer = parasail_sg_qe_db_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_striped_8_pointer = parasail_sg_qe_db_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_striped_8_pointer = parasail_sg_qe_db_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_striped_8_pointer = parasail_sg_qe_db_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_striped_8_pointer = parasail_sg_qe_db_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_striped_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23eb24
leaq 0x389871(%rip), %rax    # 0x5c8393
jmp 0x23eb53
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23eb38
leaq 0x26d198(%rip), %rax    # 0x4abcce
jmp 0x23eb53
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23eb4c
leaq 0x5c5f2(%rip), %rax     # 0x29b13c
jmp 0x23eb53
leaq 0x181a15(%rip), %rax    # 0x3c0568
movq %rax, 0x59c4fe(%rip)    # 0x7db058
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_diag_64_pointer = parasail_sg_qe_db_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_diag_64_pointer = parasail_sg_qe_db_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_diag_64_pointer = parasail_sg_qe_db_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_diag_64_pointer = parasail_sg_qe_db_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_diag_64_pointer = parasail_sg_qe_db_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_diag_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ebad
leaq 0x373019(%rip), %rax    # 0x5b1bc4
jmp 0x23ebdc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ebc1
leaq 0x25bef9(%rip), %rax    # 0x49aab8
jmp 0x23ebdc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ebd5
leaq 0x5c569(%rip), %rax     # 0x29b13c
jmp 0x23ebdc
leaq 0x16da9c(%rip), %rax    # 0x3ac678
movq %rax, 0x59c47d(%rip)    # 0x7db060
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_diag_32_pointer = parasail_sg_qe_db_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_diag_32_pointer = parasail_sg_qe_db_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_diag_32_pointer = parasail_sg_qe_db_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_diag_32_pointer = parasail_sg_qe_db_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_diag_32_pointer = parasail_sg_qe_db_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_diag_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ec36
leaq 0x375580(%rip), %rax    # 0x5b41b4
jmp 0x23ec65
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ec4a
leaq 0x25dc5f(%rip), %rax    # 0x49c8a7
jmp 0x23ec65
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ec5e
leaq 0x5c4e0(%rip), %rax     # 0x29b13c
jmp 0x23ec65
leaq 0x16fd30(%rip), %rax    # 0x3ae995
movq %rax, 0x59c3fc(%rip)    # 0x7db068
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_diag_16_pointer = parasail_sg_qe_db_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_diag_16_pointer = parasail_sg_qe_db_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_diag_16_pointer = parasail_sg_qe_db_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_diag_16_pointer = parasail_sg_qe_db_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_diag_16_pointer = parasail_sg_qe_db_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_diag_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ecbf
leaq 0x378aa7(%rip), %rax    # 0x5b7764
jmp 0x23ecee
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ecd3
leaq 0x25fff7(%rip), %rax    # 0x49ecc8
jmp 0x23ecee
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ece7
leaq 0x5c457(%rip), %rax     # 0x29b13c
jmp 0x23ecee
leaq 0x172348(%rip), %rax    # 0x3b1036
movq %rax, 0x59c37b(%rip)    # 0x7db070
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_db_trace_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_db_trace_diag_8_pointer = parasail_sg_qe_db_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_trace_diag_8_pointer = parasail_sg_qe_db_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_trace_diag_8_pointer = parasail_sg_qe_db_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_trace_diag_8_pointer = parasail_sg_qe_db_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_trace_diag_8_pointer = parasail_sg_qe_db_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_trace_diag_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_trace_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ed48
leaq 0x37da8d(%rip), %rax    # 0x5bc7d3
jmp 0x23ed77
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ed5c
leaq 0x2633f8(%rip), %rax    # 0x4a2152
jmp 0x23ed77
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ed70
leaq 0x5c3ce(%rip), %rax     # 0x29b13c
jmp 0x23ed77
leaq 0x175ced(%rip), %rax    # 0x3b4a64
movq %rax, 0x59c2fa(%rip)    # 0x7db078
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_scan_profile_64_pointer = parasail_sg_qe_db_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_profile_64_pointer = parasail_sg_qe_db_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_profile_64_pointer = parasail_sg_qe_db_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_profile_64_pointer = parasail_sg_qe_db_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_profile_64_pointer = parasail_sg_qe_db_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23edca
leaq 0x26eb51(%rip), %rax    # 0x4ad919
jmp 0x23edf0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23edde
leaq 0x183684(%rip), %rax    # 0x3c2460
jmp 0x23edf0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23ee0f
leaq 0x708fd(%rip), %rax     # 0x2af6ed
movq %rax, 0x59c289(%rip)    # 0x7db080
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_scan_profile_32_pointer = parasail_sg_qe_db_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_profile_32_pointer = parasail_sg_qe_db_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_profile_32_pointer = parasail_sg_qe_db_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_profile_32_pointer = parasail_sg_qe_db_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_profile_32_pointer = parasail_sg_qe_db_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ee44
leaq 0x2703d7(%rip), %rax    # 0x4af219
jmp 0x23ee6a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ee58
leaq 0x184fd7(%rip), %rax    # 0x3c3e2d
jmp 0x23ee6a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23ee89
leaq 0x7272b(%rip), %rax     # 0x2b1595
movq %rax, 0x59c217(%rip)    # 0x7db088
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_scan_profile_16_pointer = parasail_sg_qe_db_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_profile_16_pointer = parasail_sg_qe_db_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_profile_16_pointer = parasail_sg_qe_db_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_profile_16_pointer = parasail_sg_qe_db_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_profile_16_pointer = parasail_sg_qe_db_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23eebe
leaq 0x272754(%rip), %rax    # 0x4b1610
jmp 0x23eee4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23eed2
leaq 0x186b3c(%rip), %rax    # 0x3c5a0c
jmp 0x23eee4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23ef03
leaq 0x74788(%rip), %rax     # 0x2b366c
movq %rax, 0x59c1a5(%rip)    # 0x7db090
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_scan_profile_8_pointer = parasail_sg_qe_db_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_scan_profile_8_pointer = parasail_sg_qe_db_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_scan_profile_8_pointer = parasail_sg_qe_db_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_scan_profile_8_pointer = parasail_sg_qe_db_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_scan_profile_8_pointer = parasail_sg_qe_db_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23ef38
leaq 0x2758c4(%rip), %rax    # 0x4b47fa
jmp 0x23ef5e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ef4c
leaq 0x188ac7(%rip), %rax    # 0x3c7a11
jmp 0x23ef5e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23ef7d
leaq 0x77098(%rip), %rax     # 0x2b5ff6
movq %rax, 0x59c133(%rip)    # 0x7db098
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_db_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_qe_db_striped_profile_64_pointer = parasail_sg_qe_db_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_profile_64_pointer = parasail_sg_qe_db_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_profile_64_pointer = parasail_sg_qe_db_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_profile_64_pointer = parasail_sg_qe_db_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_profile_64_pointer = parasail_sg_qe_db_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23efb2
leaq 0x280428(%rip), %rax    # 0x4bf3d8
jmp 0x23efd8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23efc6
leaq 0x19196a(%rip), %rax    # 0x3d092e
jmp 0x23efd8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23eff7
leaq 0x81b18(%rip), %rax     # 0x2c0af0
movq %rax, 0x59c0c1(%rip)    # 0x7db0a0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_db_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_striped_profile_32_pointer = parasail_sg_qe_db_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_profile_32_pointer = parasail_sg_qe_db_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_profile_32_pointer = parasail_sg_qe_db_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_profile_32_pointer = parasail_sg_qe_db_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_profile_32_pointer = parasail_sg_qe_db_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23f02c
leaq 0x281a06(%rip), %rax    # 0x4c0a30
jmp 0x23f052
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23f040
leaq 0x193019(%rip), %rax    # 0x3d2057
jmp 0x23f052
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23f071
leaq 0x8361b(%rip), %rax     # 0x2c266d
movq %rax, 0x59c04f(%rip)    # 0x7db0a8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_db_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_striped_profile_16_pointer = parasail_sg_qe_db_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_profile_16_pointer = parasail_sg_qe_db_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_profile_16_pointer = parasail_sg_qe_db_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_profile_16_pointer = parasail_sg_qe_db_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_profile_16_pointer = parasail_sg_qe_db_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23f0a6
leaq 0x283a93(%rip), %rax    # 0x4c2b37
jmp 0x23f0cc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23f0ba
leaq 0x194908(%rip), %rax    # 0x3d39c0
jmp 0x23f0cc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23f0eb
leaq 0x85322(%rip), %rax     # 0x2c43ee
movq %rax, 0x59bfdd(%rip)    # 0x7db0b0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_db_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_striped_profile_8_pointer = parasail_sg_qe_db_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_striped_profile_8_pointer = parasail_sg_qe_db_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_striped_profile_8_pointer = parasail_sg_qe_db_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_striped_profile_8_pointer = parasail_sg_qe_db_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_striped_profile_8_pointer = parasail_sg_qe_db_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23f120
leaq 0x286942(%rip), %rax    # 0x4c5a60
jmp 0x23f146
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23f134
leaq 0x1965fa(%rip), %rax    # 0x3d572c
jmp 0x23f146
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23f165
leaq 0x878aa(%rip), %rax     # 0x2c69f0
movq %rax, 0x59bf6b(%rip)    # 0x7db0b8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_qe_db_stats_scan_profile_64_pointer = parasail_sg_qe_db_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_profile_64_pointer = parasail_sg_qe_db_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_profile_64_pointer = parasail_sg_qe_db_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_profile_64_pointer = parasail_sg_qe_db_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_profile_64_pointer = parasail_sg_qe_db_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_stats_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23f19a
leaq 0x2890a8(%rip), %rax    # 0x4c8240
jmp 0x23f1c0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23f1ae
leaq 0x199510(%rip), %rax    # 0x3d86bc
jmp 0x23f1c0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23f1df
leaq 0x8ac5d(%rip), %rax     # 0x2c9e1d
movq %rax, 0x59bef9(%rip)    # 0x7db0c0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_qe_db_stats_scan_profile_32_pointer = parasail_sg_qe_db_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_profile_32_pointer = parasail_sg_qe_db_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_profile_32_pointer = parasail_sg_qe_db_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_profile_32_pointer = parasail_sg_qe_db_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_profile_32_pointer = parasail_sg_qe_db_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_db_stats_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x23f214
leaq 0x28bfbc(%rip), %rax    # 0x4cb1ce
jmp 0x23f23a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23f228
leaq 0x19c549(%rip), %rax    # 0x3db76f
jmp 0x23f23a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
je 0x23f259
leaq 0x8e510(%rip), %rax     # 0x2cd74a
movq %rax, 0x59be87(%rip)    # 0x7db0c8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq