LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_db_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23fbbd
leaq 0x24d3d8(%rip), %rax    # 0x48cf93
jmp 0x23fbec
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23fbd1
leaq 0x16931f(%rip), %rax    # 0x3a8eee
jmp 0x23fbec
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23fbe5
leaq 0x59fad(%rip), %rax     # 0x299b90
jmp 0x23fbec
leaq 0x72eb0(%rip), %rax     # 0x2b2a9c
movq %rax, 0x56568d(%rip)    # 0x7a5280
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_db_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23fc46
leaq 0x24f356(%rip), %rax    # 0x48ef9a
jmp 0x23fc75
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23fc5a
leaq 0x16ac9a(%rip), %rax    # 0x3aa8f2
jmp 0x23fc75
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23fc6e
leaq 0x59f24(%rip), %rax     # 0x299b90
jmp 0x23fc75
leaq 0x74b46(%rip), %rax     # 0x2b47bb
movq %rax, 0x56560c(%rip)    # 0x7a5288
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_db_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23fccf
leaq 0x251797(%rip), %rax    # 0x491464
jmp 0x23fcfe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23fce3
leaq 0x16c859(%rip), %rax    # 0x3ac53a
jmp 0x23fcfe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23fcf7
leaq 0x59e9b(%rip), %rax     # 0x299b90
jmp 0x23fcfe
leaq 0x7691c(%rip), %rax     # 0x2b661a
movq %rax, 0x56558b(%rip)    # 0x7a5290
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_db_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23fd58
leaq 0x254dc4(%rip), %rax    # 0x494b1a
jmp 0x23fd87
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23fd6c
leaq 0x16ec7a(%rip), %rax    # 0x3ae9e4
jmp 0x23fd87
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23fd80
leaq 0x59e12(%rip), %rax     # 0x299b90
jmp 0x23fd87
leaq 0x79115(%rip), %rax     # 0x2b8e9c
movq %rax, 0x56550a(%rip)    # 0x7a5298
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23fde1
leaq 0x25eb78(%rip), %rax    # 0x49e957
jmp 0x23fe10
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23fdf5
leaq 0x177d0f(%rip), %rax    # 0x3b7b02
jmp 0x23fe10
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23fe09
leaq 0x5ac07(%rip), %rax     # 0x29aa0e
jmp 0x23fe10
leaq 0x82654(%rip), %rax     # 0x2c2464
movq %rax, 0x565489(%rip)    # 0x7a52a0
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23fe6a
leaq 0x261f52(%rip), %rax    # 0x4a1dba
jmp 0x23fe99
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23fe7e
leaq 0x17ad3a(%rip), %rax    # 0x3babb6
jmp 0x23fe99
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23fe92
leaq 0x5ab7e(%rip), %rax     # 0x29aa0e
jmp 0x23fe99
leaq 0x85ca8(%rip), %rax     # 0x2c5b41
movq %rax, 0x565408(%rip)    # 0x7a52a8
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23fef3
leaq 0x264d65(%rip), %rax    # 0x4a4c56
jmp 0x23ff22
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ff07
leaq 0x17daec(%rip), %rax    # 0x3bd9f1
jmp 0x23ff22
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ff1b
leaq 0x5aaf5(%rip), %rax     # 0x29aa0e
jmp 0x23ff22
leaq 0x88ef4(%rip), %rax     # 0x2c8e16
movq %rax, 0x565387(%rip)    # 0x7a52b0
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x23ff7c
leaq 0x267b9e(%rip), %rax    # 0x4a7b18
jmp 0x23ffab
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23ff90
leaq 0x180941(%rip), %rax    # 0x3c08cf
jmp 0x23ffab
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23ffa4
leaq 0x5aa6c(%rip), %rax     # 0x29aa0e
jmp 0x23ffab
leaq 0x8c304(%rip), %rax     # 0x2cc2af
movq %rax, 0x565306(%rip)    # 0x7a52b8
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x240005
leaq 0x27c5a0(%rip), %rax    # 0x4bc5a3
jmp 0x240034
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x240019
leaq 0x192028(%rip), %rax    # 0x3d203f
jmp 0x240034
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x24002d
leaq 0x59b65(%rip), %rax     # 0x299b90
jmp 0x240034
leaq 0x9faea(%rip), %rax     # 0x2dfb1e
movq %rax, 0x565285(%rip)    # 0x7a52c0
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x24008e
leaq 0x27f525(%rip), %rax    # 0x4bf5b1
jmp 0x2400bd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2400a2
leaq 0x194dad(%rip), %rax    # 0x3d4e4d
jmp 0x2400bd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2400b6
leaq 0x59adc(%rip), %rax     # 0x299b90
jmp 0x2400bd
leaq 0xa2ed1(%rip), %rax     # 0x2e2f8e
movq %rax, 0x565204(%rip)    # 0x7a52c8
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x240117
leaq 0x28204c(%rip), %rax    # 0x4c2161
jmp 0x240146
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24012b
leaq 0x197940(%rip), %rax    # 0x3d7a69
jmp 0x240146
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x24013f
leaq 0x59a53(%rip), %rax     # 0x299b90
jmp 0x240146
leaq 0xa5e18(%rip), %rax     # 0x2e5f5e
movq %rax, 0x565183(%rip)    # 0x7a52d0
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x594f9c
testl %eax, %eax
je 0x2401a0
leaq 0x284c0c(%rip), %rax    # 0x4c4daa
jmp 0x2401cf
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2401b4
leaq 0x19a577(%rip), %rax    # 0x3da729
jmp 0x2401cf
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2401c8
leaq 0x599ca(%rip), %rax     # 0x299b90
jmp 0x2401cf
leaq 0xa8fac(%rip), %rax     # 0x2e917b
movq %rax, 0x565102(%rip)    # 0x7a52d8
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x240229
leaq 0x26b2f6(%rip), %rax    # 0x4ab51d
jmp 0x240258
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24023d
leaq 0x183aea(%rip), %rax    # 0x3c3d25
jmp 0x240258
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x240251
leaq 0x59941(%rip), %rax     # 0x299b90
jmp 0x240258
leaq 0x8fc47(%rip), %rax     # 0x2cfe9f
movq %rax, 0x565081(%rip)    # 0x7a52e0
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x2402b2
leaq 0x26ec81(%rip), %rax    # 0x4aef31
jmp 0x2402e1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2402c6
leaq 0x186d36(%rip), %rax    # 0x3c6ffa
jmp 0x2402e1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2402da
leaq 0x598b8(%rip), %rax     # 0x299b90
jmp 0x2402e1
leaq 0x9358f(%rip), %rax     # 0x2d3870
movq %rax, 0x565000(%rip)    # 0x7a52e8
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x24033b
leaq 0x272b31(%rip), %rax    # 0x4b2e6a
jmp 0x24036a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24034f
leaq 0x18a3ea(%rip), %rax    # 0x3ca737
jmp 0x24036a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x240363
leaq 0x5982f(%rip), %rax     # 0x299b90
jmp 0x24036a
leaq 0x96fea(%rip), %rax     # 0x2d7354
movq %rax, 0x564f7f(%rip)    # 0x7a52f0
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x2403c4
leaq 0x277e34(%rip), %rax    # 0x4b81f6
jmp 0x2403f3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2403d8
leaq 0x18e47a(%rip), %rax    # 0x3ce850
jmp 0x2403f3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2403ec
leaq 0x597a6(%rip), %rax     # 0x299b90
jmp 0x2403f3
leaq 0x9b7c5(%rip), %rax     # 0x2dbbb8
movq %rax, 0x564efe(%rip)    # 0x7a52f8
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_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 0x24044d
leaq 0x2885cc(%rip), %rax    # 0x4c8a17
jmp 0x24047c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x240461
leaq 0x19c693(%rip), %rax    # 0x3dcaf2
jmp 0x24047c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x240475
leaq 0x5a59b(%rip), %rax     # 0x29aa0e
jmp 0x24047c
leaq 0xac2e0(%rip), %rax     # 0x2ec75c
movq %rax, 0x564e7d(%rip)    # 0x7a5300
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_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 0x2404d6
leaq 0x28a4dd(%rip), %rax    # 0x4ca9b1
jmp 0x240505
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2404ea
leaq 0x19df8f(%rip), %rax    # 0x3de477
jmp 0x240505
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2404fe
leaq 0x5a512(%rip), %rax     # 0x29aa0e
jmp 0x240505
leaq 0xade3d(%rip), %rax     # 0x2ee342
movq %rax, 0x564dfc(%rip)    # 0x7a5308
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_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 0x24055f
leaq 0x28c2f1(%rip), %rax    # 0x4cc84e
jmp 0x24058e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x240573
leaq 0x19f9c5(%rip), %rax    # 0x3dff36
jmp 0x24058e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x240587
leaq 0x5a489(%rip), %rax     # 0x29aa0e
jmp 0x24058e
leaq 0xaf982(%rip), %rax     # 0x2eff10
movq %rax, 0x564d7b(%rip)    # 0x7a5310
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_scan_8_pointer = parasail_sg_qb_db_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_8_pointer = parasail_sg_qb_db_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_8_pointer = parasail_sg_qb_db_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_8_pointer = parasail_sg_qb_db_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_8_pointer = parasail_sg_qb_db_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_scan_8_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_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 0x2405e8
leaq 0x28e610(%rip), %rax    # 0x4cebf6
jmp 0x240617
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2405fc
leaq 0x1a17fe(%rip), %rax    # 0x3e1df8
jmp 0x240617
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x240610
leaq 0x5a400(%rip), %rax     # 0x29aa0e
jmp 0x240617
leaq 0xb1ac3(%rip), %rax     # 0x2f20da
movq %rax, 0x564cfa(%rip)    # 0x7a5318
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_64_pointer = parasail_sg_qb_db_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_64_pointer = parasail_sg_qb_db_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_64_pointer = parasail_sg_qb_db_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_64_pointer = parasail_sg_qb_db_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_64_pointer = parasail_sg_qb_db_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_striped_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x240671
leaq 0x29f960(%rip), %rax    # 0x4dffcf
jmp 0x2406a0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x240685
leaq 0x1ad4ae(%rip), %rax    # 0x3edb31
jmp 0x2406a0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x240699
leaq 0x594f9(%rip), %rax     # 0x299b90
jmp 0x2406a0
leaq 0xbe7f5(%rip), %rax     # 0x2fee95
movq %rax, 0x564c79(%rip)    # 0x7a5320
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_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_32_pointer = parasail_sg_qb_db_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_32_pointer = parasail_sg_qb_db_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_32_pointer = parasail_sg_qb_db_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_32_pointer = parasail_sg_qb_db_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_32_pointer = parasail_sg_qb_db_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_striped_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x2406fa
leaq 0x2a14b4(%rip), %rax    # 0x4e1bac
jmp 0x240729
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24070e
leaq 0x1aec4b(%rip), %rax    # 0x3ef357
jmp 0x240729
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x240722
leaq 0x59470(%rip), %rax     # 0x299b90
jmp 0x240729
leaq 0xc01df(%rip), %rax     # 0x300908
movq %rax, 0x564bf8(%rip)    # 0x7a5328
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