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_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x23c525
leaq 0x279ddf(%rip), %rax    # 0x4b6302
jmp 0x23c554
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c539
leaq 0x18cd6d(%rip), %rax    # 0x3c92a4
jmp 0x23c554
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c54d
leaq 0x5ebf1(%rip), %rax     # 0x29b13c
jmp 0x23c554
leaq 0x7ba29(%rip), %rax     # 0x2b7f7d
movq %rax, 0x59e8c5(%rip)    # 0x7dae20
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_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x23c5ae
leaq 0x27ba32(%rip), %rax    # 0x4b7fde
jmp 0x23c5dd
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c5c2
leaq 0x18e55e(%rip), %rax    # 0x3cab1e
jmp 0x23c5dd
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c5d6
leaq 0x5eb68(%rip), %rax     # 0x29b13c
jmp 0x23c5dd
leaq 0x7d6af(%rip), %rax     # 0x2b9c8c
movq %rax, 0x59e844(%rip)    # 0x7dae28
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_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x23c637
leaq 0x27de0f(%rip), %rax    # 0x4ba444
jmp 0x23c666
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c64b
leaq 0x1900a5(%rip), %rax    # 0x3cc6ee
jmp 0x23c666
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c65f
leaq 0x5eadf(%rip), %rax     # 0x29b13c
jmp 0x23c666
leaq 0x7f4a6(%rip), %rax     # 0x2bbb0c
movq %rax, 0x59e7c3(%rip)    # 0x7dae30
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_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_diag_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_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 0x23c6c0
leaq 0x280cdb(%rip), %rax    # 0x4bd399
jmp 0x23c6ef
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c6d4
leaq 0x192397(%rip), %rax    # 0x3cea69
jmp 0x23c6ef
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c6e8
leaq 0x5ea56(%rip), %rax     # 0x29b13c
jmp 0x23c6ef
leaq 0x81dd9(%rip), %rax     # 0x2be4c8
movq %rax, 0x59e742(%rip)    # 0x7dae38
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_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x23c749
leaq 0x28b9bc(%rip), %rax    # 0x4c8103
jmp 0x23c778
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c75d
leaq 0x19be24(%rip), %rax    # 0x3d857f
jmp 0x23c778
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c771
leaq 0x5fcc9(%rip), %rax     # 0x29c438
jmp 0x23c778
leaq 0x8d568(%rip), %rax     # 0x2c9ce0
movq %rax, 0x59e6c1(%rip)    # 0x7dae40
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_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x23c7d2
leaq 0x28e8c1(%rip), %rax    # 0x4cb091
jmp 0x23c801
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c7e6
leaq 0x19ee4e(%rip), %rax    # 0x3db632
jmp 0x23c801
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c7fa
leaq 0x5fc40(%rip), %rax     # 0x29c438
jmp 0x23c801
leaq 0x90e0c(%rip), %rax     # 0x2cd60d
movq %rax, 0x59e640(%rip)    # 0x7dae48
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_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x23c85b
leaq 0x292004(%rip), %rax    # 0x4ce85d
jmp 0x23c88a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c86f
leaq 0x1a2211(%rip), %rax    # 0x3dea7e
jmp 0x23c88a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c883
leaq 0x5fbb7(%rip), %rax     # 0x29c438
jmp 0x23c88a
leaq 0x949b5(%rip), %rax     # 0x2d123f
movq %rax, 0x59e5bf(%rip)    # 0x7dae50
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_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_scan_8_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x23c8e4
leaq 0x296275(%rip), %rax    # 0x4d2b57
jmp 0x23c913
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c8f8
leaq 0x1a5a11(%rip), %rax    # 0x3e2307
jmp 0x23c913
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c90c
leaq 0x5fb2e(%rip), %rax     # 0x29c438
jmp 0x23c913
leaq 0x98eaf(%rip), %rax     # 0x2d57c2
movq %rax, 0x59e53e(%rip)    # 0x7dae58
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_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23c96d
leaq 0x2a929c(%rip), %rax    # 0x4e5c07
jmp 0x23c99c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23c981
leaq 0x1b69c5(%rip), %rax    # 0x3f3344
jmp 0x23c99c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23c995
leaq 0x5e7a9(%rip), %rax     # 0x29b13c
jmp 0x23c99c
leaq 0xad0d9(%rip), %rax     # 0x2e9a75
movq %rax, 0x59e4bd(%rip)    # 0x7dae60
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_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23c9f6
leaq 0x2abf4f(%rip), %rax    # 0x4e8943
jmp 0x23ca25
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ca0a
leaq 0x1b97bc(%rip), %rax    # 0x3f61c4
jmp 0x23ca25
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ca1e
leaq 0x5e720(%rip), %rax     # 0x29b13c
jmp 0x23ca25
leaq 0xb0a0f(%rip), %rax     # 0x2ed434
movq %rax, 0x59e43c(%rip)    # 0x7dae68
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_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23ca7f
leaq 0x2af65c(%rip), %rax    # 0x4ec0d9
jmp 0x23caae
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ca93
leaq 0x1bc944(%rip), %rax    # 0x3f93d5
jmp 0x23caae
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23caa7
leaq 0x5e697(%rip), %rax     # 0x29b13c
jmp 0x23caae
leaq 0xb40bb(%rip), %rax     # 0x2f0b69
movq %rax, 0x59e3bb(%rip)    # 0x7dae70
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_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23cb08
leaq 0x2b3cea(%rip), %rax    # 0x4f07f0
jmp 0x23cb37
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cb1c
leaq 0x1bfeb9(%rip), %rax    # 0x3fc9d3
jmp 0x23cb37
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23cb30
leaq 0x5e60e(%rip), %rax     # 0x29b13c
jmp 0x23cb37
leaq 0xb8158(%rip), %rax     # 0x2f4c8f
movq %rax, 0x59e33a(%rip)    # 0x7dae78
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_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23cb91
leaq 0x2993a7(%rip), %rax    # 0x4d5f36
jmp 0x23cbc0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cba5
leaq 0x1a89d2(%rip), %rax    # 0x3e5575
jmp 0x23cbc0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23cbb9
leaq 0x5e585(%rip), %rax     # 0x29b13c
jmp 0x23cbc0
leaq 0x9c9c3(%rip), %rax     # 0x2d9583
movq %rax, 0x59e2b9(%rip)    # 0x7dae80
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_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23cc1a
leaq 0x29c91f(%rip), %rax    # 0x4d9537
jmp 0x23cc49
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cc2e
leaq 0x1abaae(%rip), %rax    # 0x3e86da
jmp 0x23cc49
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23cc42
leaq 0x5e4fc(%rip), %rax     # 0x29b13c
jmp 0x23cc49
leaq 0xa03ca(%rip), %rax     # 0x2dd013
movq %rax, 0x59e238(%rip)    # 0x7dae88
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_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23cca3
leaq 0x2a086a(%rip), %rax    # 0x4dd50b
jmp 0x23ccd2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ccb7
leaq 0x1af130(%rip), %rax    # 0x3ebde5
jmp 0x23ccd2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23cccb
leaq 0x5e473(%rip), %rax     # 0x29b13c
jmp 0x23ccd2
leaq 0xa3d5f(%rip), %rax     # 0x2e0a31
movq %rax, 0x59e1b7(%rip)    # 0x7dae90
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_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x23cd2c
leaq 0x2a55f5(%rip), %rax    # 0x4e231f
jmp 0x23cd5b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cd40
leaq 0x1b3143(%rip), %rax    # 0x3efe81
jmp 0x23cd5b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23cd54
leaq 0x5e3ea(%rip), %rax     # 0x29b13c
jmp 0x23cd5b
leaq 0xa8904(%rip), %rax     # 0x2e565f
movq %rax, 0x59e136(%rip)    # 0x7dae98
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_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_scan_64_pointer = parasail_sg_qe_db_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_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 0x23cdb5
leaq 0x2b6ebf(%rip), %rax    # 0x4f3c72
jmp 0x23cde4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cdc9
leaq 0x1c1e77(%rip), %rax    # 0x3fec3e
jmp 0x23cde4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23cddd
leaq 0x5f65d(%rip), %rax     # 0x29c438
jmp 0x23cde4
leaq 0xbb9e4(%rip), %rax     # 0x2f87c8
movq %rax, 0x59e0b5(%rip)    # 0x7daea0
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_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_scan_32_pointer = parasail_sg_qe_db_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_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 0x23ce3e
leaq 0x2b8af9(%rip), %rax    # 0x4f5935
jmp 0x23ce6d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23ce52
leaq 0x1c3985(%rip), %rax    # 0x4007d5
jmp 0x23ce6d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ce66
leaq 0x5f5d4(%rip), %rax     # 0x29c438
jmp 0x23ce6d
leaq 0xbd9b7(%rip), %rax     # 0x2fa824
movq %rax, 0x59e034(%rip)    # 0x7daea8
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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_scan_16_pointer = parasail_sg_qe_db_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_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 0x23cec7
leaq 0x2bb64f(%rip), %rax    # 0x4f8514
jmp 0x23cef6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cedb
leaq 0x1c593f(%rip), %rax    # 0x402818
jmp 0x23cef6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23ceef
leaq 0x5f54b(%rip), %rax     # 0x29c438
jmp 0x23cef6
leaq 0xbfdc0(%rip), %rax     # 0x2fccb6
movq %rax, 0x59dfb3(%rip)    # 0x7daeb0
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_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_scan_8_pointer = parasail_sg_qe_db_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_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 0x23cf50
leaq 0x2bf462(%rip), %rax    # 0x4fc3b0
jmp 0x23cf7f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cf64
leaq 0x1c80af(%rip), %rax    # 0x405011
jmp 0x23cf7f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23cf78
leaq 0x5f4c2(%rip), %rax     # 0x29c438
jmp 0x23cf7f
leaq 0xc2e82(%rip), %rax     # 0x2ffe01
movq %rax, 0x59df32(%rip)    # 0x7daeb8
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_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_striped_64_pointer = parasail_sg_qe_db_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x23cfd9
leaq 0x2ced6d(%rip), %rax    # 0x50bd44
jmp 0x23d008
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23cfed
leaq 0x1d35da(%rip), %rax    # 0x4105c5
jmp 0x23d008
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23d001
leaq 0x5e13d(%rip), %rax     # 0x29b13c
jmp 0x23d008
leaq 0xd0007(%rip), %rax     # 0x30d00f
movq %rax, 0x59deb1(%rip)    # 0x7daec0
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_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_striped_32_pointer = parasail_sg_qe_db_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x23d062
leaq 0x2d0784(%rip), %rax    # 0x50d7e4
jmp 0x23d091
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23d076
leaq 0x1d4e45(%rip), %rax    # 0x411eb9
jmp 0x23d091
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23d08a
leaq 0x5e0b4(%rip), %rax     # 0x29b13c
jmp 0x23d091
leaq 0xd1d58(%rip), %rax     # 0x30ede9
movq %rax, 0x59de30(%rip)    # 0x7daec8
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