LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x23b599
leaq 0x26ff64(%rip), %rax    # 0x4ab4fb
jmp 0x23b5c8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b5ad
leaq 0x188758(%rip), %rax    # 0x3c3d03
jmp 0x23b5c8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b5c1
leaq 0x5e5af(%rip), %rax     # 0x299b6e
jmp 0x23b5c8
leaq 0x948b5(%rip), %rax     # 0x2cfe7d
movq %rax, 0x5698b1(%rip)    # 0x7a4e80
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b622
leaq 0x2738ef(%rip), %rax    # 0x4aef0f
jmp 0x23b651
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b636
leaq 0x18b9a4(%rip), %rax    # 0x3c6fd8
jmp 0x23b651
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b64a
leaq 0x5e526(%rip), %rax     # 0x299b6e
jmp 0x23b651
leaq 0x981fd(%rip), %rax     # 0x2d384e
movq %rax, 0x569830(%rip)    # 0x7a4e88
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b6ab
leaq 0x27779f(%rip), %rax    # 0x4b2e48
jmp 0x23b6da
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b6bf
leaq 0x18f058(%rip), %rax    # 0x3ca715
jmp 0x23b6da
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b6d3
leaq 0x5e49d(%rip), %rax     # 0x299b6e
jmp 0x23b6da
leaq 0x9bc58(%rip), %rax     # 0x2d7332
movq %rax, 0x5697af(%rip)    # 0x7a4e90
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b734
leaq 0x27caa2(%rip), %rax    # 0x4b81d4
jmp 0x23b763
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b748
leaq 0x1930e8(%rip), %rax    # 0x3ce82e
jmp 0x23b763
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b75c
leaq 0x5e414(%rip), %rax     # 0x299b6e
jmp 0x23b763
leaq 0xa0433(%rip), %rax     # 0x2dbb96
movq %rax, 0x56972e(%rip)    # 0x7a4e98
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b7bd
leaq 0x28d23a(%rip), %rax    # 0x4c89f5
jmp 0x23b7ec
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b7d1
leaq 0x1a1301(%rip), %rax    # 0x3dcad0
jmp 0x23b7ec
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b7e5
leaq 0x5f209(%rip), %rax     # 0x29a9ec
jmp 0x23b7ec
leaq 0xb0f4e(%rip), %rax     # 0x2ec73a
movq %rax, 0x5696ad(%rip)    # 0x7a4ea0
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b846
leaq 0x28f14b(%rip), %rax    # 0x4ca98f
jmp 0x23b875
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b85a
leaq 0x1a2bfd(%rip), %rax    # 0x3de455
jmp 0x23b875
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b86e
leaq 0x5f180(%rip), %rax     # 0x29a9ec
jmp 0x23b875
leaq 0xb2aab(%rip), %rax     # 0x2ee320
movq %rax, 0x56962c(%rip)    # 0x7a4ea8
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b8cf
leaq 0x290f5f(%rip), %rax    # 0x4cc82c
jmp 0x23b8fe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b8e3
leaq 0x1a4633(%rip), %rax    # 0x3dff14
jmp 0x23b8fe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b8f7
leaq 0x5f0f7(%rip), %rax     # 0x29a9ec
jmp 0x23b8fe
leaq 0xb45f0(%rip), %rax     # 0x2efeee
movq %rax, 0x5695ab(%rip)    # 0x7a4eb0
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b958
leaq 0x29327e(%rip), %rax    # 0x4cebd4
jmp 0x23b987
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b96c
leaq 0x1a646c(%rip), %rax    # 0x3e1dd6
jmp 0x23b987
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23b980
leaq 0x5f06e(%rip), %rax     # 0x29a9ec
jmp 0x23b987
leaq 0xb6731(%rip), %rax     # 0x2f20b8
movq %rax, 0x56952a(%rip)    # 0x7a4eb8
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23b9e1
leaq 0x2a45ce(%rip), %rax    # 0x4dffad
jmp 0x23ba10
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23b9f5
leaq 0x1b211c(%rip), %rax    # 0x3edb0f
jmp 0x23ba10
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ba09
leaq 0x5e167(%rip), %rax     # 0x299b6e
jmp 0x23ba10
leaq 0xc3463(%rip), %rax     # 0x2fee73
movq %rax, 0x5694a9(%rip)    # 0x7a4ec0
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_O1/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 0x594f9c
testl %eax, %eax
je 0x23ba6a
leaq 0x2a6122(%rip), %rax    # 0x4e1b8a
jmp 0x23ba99
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ba7e
leaq 0x1b38b9(%rip), %rax    # 0x3ef335
jmp 0x23ba99
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ba92
leaq 0x5e0de(%rip), %rax     # 0x299b6e
jmp 0x23ba99
leaq 0xc4e4d(%rip), %rax     # 0x3008e6
movq %rax, 0x569428(%rip)    # 0x7a4ec8
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_striped_16_pointer = parasail_sg_qe_db_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x594f9c
testl %eax, %eax
je 0x23baf3
leaq 0x2a8090(%rip), %rax    # 0x4e3b81
jmp 0x23bb22
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bb07
leaq 0x1b519c(%rip), %rax    # 0x3f0ca1
jmp 0x23bb22
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bb1b
leaq 0x5e055(%rip), %rax     # 0x299b6e
jmp 0x23bb22
leaq 0xc67f5(%rip), %rax     # 0x302317
movq %rax, 0x5693a7(%rip)    # 0x7a4ed0
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_striped_8_pointer = parasail_sg_qe_db_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x594f9c
testl %eax, %eax
je 0x23bb7c
leaq 0x2aa69b(%rip), %rax    # 0x4e6215
jmp 0x23bbab
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bb90
leaq 0x1b70eb(%rip), %rax    # 0x3f2c79
jmp 0x23bbab
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bba4
leaq 0x5dfcc(%rip), %rax     # 0x299b6e
jmp 0x23bbab
leaq 0xc8b0d(%rip), %rax     # 0x3046b8
movq %rax, 0x569326(%rip)    # 0x7a4ed8
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_diag_64_pointer = parasail_sg_qe_db_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x594f9c
testl %eax, %eax
je 0x23bc05
leaq 0x295813(%rip), %rax    # 0x4d1416
jmp 0x23bc34
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bc19
leaq 0x1a80cb(%rip), %rax    # 0x3e3ce2
jmp 0x23bc34
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bc2d
leaq 0x5df43(%rip), %rax     # 0x299b6e
jmp 0x23bc34
leaq 0xb877c(%rip), %rax     # 0x2f43b0
movq %rax, 0x5692a5(%rip)    # 0x7a4ee0
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_diag_32_pointer = parasail_sg_qe_db_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x594f9c
testl %eax, %eax
je 0x23bc8e
leaq 0x297f4e(%rip), %rax    # 0x4d3bda
jmp 0x23bcbd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bca2
leaq 0x1a9dba(%rip), %rax    # 0x3e5a5a
jmp 0x23bcbd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bcb6
leaq 0x5deba(%rip), %rax     # 0x299b6e
jmp 0x23bcbd
leaq 0xba7fa(%rip), %rax     # 0x2f64b7
movq %rax, 0x569224(%rip)    # 0x7a4ee8
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_diag_16_pointer = parasail_sg_qe_db_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x594f9c
testl %eax, %eax
je 0x23bd17
leaq 0x29b349(%rip), %rax    # 0x4d705e
jmp 0x23bd46
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bd2b
leaq 0x1ac16f(%rip), %rax    # 0x3e7e98
jmp 0x23bd46
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bd3f
leaq 0x5de31(%rip), %rax     # 0x299b6e
jmp 0x23bd46
leaq 0xbce56(%rip), %rax     # 0x2f8b9c
movq %rax, 0x5691a3(%rip)    # 0x7a4ef0
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_db_table_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_table_diag_8_pointer = parasail_sg_qe_db_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_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 0x594f9c
testl %eax, %eax
je 0x23bda0
leaq 0x2a0803(%rip), %rax    # 0x4dc5a1
jmp 0x23bdcf
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bdb4
leaq 0x1af52f(%rip), %rax    # 0x3eb2e1
jmp 0x23bdcf
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bdc8
leaq 0x5dda8(%rip), %rax     # 0x299b6e
jmp 0x23bdcf
leaq 0xc0653(%rip), %rax     # 0x2fc422
movq %rax, 0x569122(%rip)    # 0x7a4ef8
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x594f9c
testl %eax, %eax
je 0x23be29
leaq 0x2ae076(%rip), %rax    # 0x4e9e9d
jmp 0x23be58
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23be3d
leaq 0x1ba833(%rip), %rax    # 0x3f666e
jmp 0x23be58
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23be51
leaq 0x5eb9d(%rip), %rax     # 0x29a9ec
jmp 0x23be58
leaq 0xcbf01(%rip), %rax     # 0x307d59
movq %rax, 0x5690a1(%rip)    # 0x7a4f00
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x594f9c
testl %eax, %eax
je 0x23beb2
leaq 0x2b1b49(%rip), %rax    # 0x4ed9f9
jmp 0x23bee1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bec6
leaq 0x1bdcca(%rip), %rax    # 0x3f9b8e
jmp 0x23bee1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23beda
leaq 0x5eb14(%rip), %rax     # 0x29a9ec
jmp 0x23bee1
leaq 0xcf982(%rip), %rax     # 0x30b863
movq %rax, 0x569020(%rip)    # 0x7a4f08
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x594f9c
testl %eax, %eax
je 0x23bf3b
leaq 0x2b5912(%rip), %rax    # 0x4f184b
jmp 0x23bf6a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bf4f
leaq 0x1c13c3(%rip), %rax    # 0x3fd310
jmp 0x23bf6a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bf63
leaq 0x5ea8b(%rip), %rax     # 0x29a9ec
jmp 0x23bf6a
leaq 0xd34d8(%rip), %rax     # 0x30f442
movq %rax, 0x568f9f(%rip)    # 0x7a4f10
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_table_scan_8_pointer = parasail_sg_qe_db_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_scan_8_pointer = parasail_sg_qe_db_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_scan_8_pointer = parasail_sg_qe_db_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_scan_8_pointer = parasail_sg_qe_db_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_scan_8_pointer = parasail_sg_qe_db_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_scan_8_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_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 0x594f9c
testl %eax, %eax
je 0x23bfc4
leaq 0x2b9b61(%rip), %rax    # 0x4f5b23
jmp 0x23bff3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23bfd8
leaq 0x1c5323(%rip), %rax    # 0x4012f9
jmp 0x23bff3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23bfec
leaq 0x5ea02(%rip), %rax     # 0x29a9ec
jmp 0x23bff3
leaq 0xd7995(%rip), %rax     # 0x313988
movq %rax, 0x568f1e(%rip)    # 0x7a4f18
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_O1/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_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_stats_table_striped_64_pointer = parasail_sg_qe_db_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_striped_64_pointer = parasail_sg_qe_db_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_striped_64_pointer = parasail_sg_qe_db_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_striped_64_pointer = parasail_sg_qe_db_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_striped_64_pointer = parasail_sg_qe_db_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_striped_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_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 0x594f9c
testl %eax, %eax
je 0x23c04d
leaq 0x2d4668(%rip), %rax    # 0x5106b3
jmp 0x23c07c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23c061
leaq 0x1da1c6(%rip), %rax    # 0x416225
jmp 0x23c07c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23c075
leaq 0x5dafb(%rip), %rax     # 0x299b6e
jmp 0x23c07c
leaq 0xee55d(%rip), %rax     # 0x32a5d9
movq %rax, 0x568e9d(%rip)    # 0x7a4f20
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