LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5c8fdb
testl %eax, %eax
je 0x24170f
leaq 0x2aa9ee(%rip), %rax    # 0x4ec0fb
jmp 0x24173e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241723
leaq 0x1b7cd6(%rip), %rax    # 0x3f93f7
jmp 0x24173e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241737
leaq 0x59a29(%rip), %rax     # 0x29b15e
jmp 0x24173e
leaq 0xaf44d(%rip), %rax     # 0x2f0b8b
movq %rax, 0x599b8b(%rip)    # 0x7db2d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241798
leaq 0x2af07c(%rip), %rax    # 0x4f0812
jmp 0x2417c7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2417ac
leaq 0x1bb24b(%rip), %rax    # 0x3fc9f5
jmp 0x2417c7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2417c0
leaq 0x599a0(%rip), %rax     # 0x29b15e
jmp 0x2417c7
leaq 0xb34ea(%rip), %rax     # 0x2f4cb1
movq %rax, 0x599b0a(%rip)    # 0x7db2d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241821
leaq 0x294739(%rip), %rax    # 0x4d5f58
jmp 0x241850
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241835
leaq 0x1a3d64(%rip), %rax    # 0x3e5597
jmp 0x241850
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241849
leaq 0x59917(%rip), %rax     # 0x29b15e
jmp 0x241850
leaq 0x97d55(%rip), %rax     # 0x2d95a5
movq %rax, 0x599a89(%rip)    # 0x7db2e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x2418aa
leaq 0x297cb1(%rip), %rax    # 0x4d9559
jmp 0x2418d9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2418be
leaq 0x1a6e40(%rip), %rax    # 0x3e86fc
jmp 0x2418d9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2418d2
leaq 0x5988e(%rip), %rax     # 0x29b15e
jmp 0x2418d9
leaq 0x9b75c(%rip), %rax     # 0x2dd035
movq %rax, 0x599a08(%rip)    # 0x7db2e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241933
leaq 0x29bbfc(%rip), %rax    # 0x4dd52d
jmp 0x241962
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241947
leaq 0x1aa4c2(%rip), %rax    # 0x3ebe07
jmp 0x241962
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x24195b
leaq 0x59805(%rip), %rax     # 0x29b15e
jmp 0x241962
leaq 0x9f0f1(%rip), %rax     # 0x2e0a53
movq %rax, 0x599987(%rip)    # 0x7db2f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x2419bc
leaq 0x2a0987(%rip), %rax    # 0x4e2341
jmp 0x2419eb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2419d0
leaq 0x1ae4d5(%rip), %rax    # 0x3efea3
jmp 0x2419eb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2419e4
leaq 0x5977c(%rip), %rax     # 0x29b15e
jmp 0x2419eb
leaq 0xa3c96(%rip), %rax     # 0x2e5681
movq %rax, 0x599906(%rip)    # 0x7db2f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241a45
leaq 0x2b2251(%rip), %rax    # 0x4f3c94
jmp 0x241a74
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241a59
leaq 0x1bd209(%rip), %rax    # 0x3fec60
jmp 0x241a74
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241a6d
leaq 0x5a9ef(%rip), %rax     # 0x29c45a
jmp 0x241a74
leaq 0xb6d76(%rip), %rax     # 0x2f87ea
movq %rax, 0x599885(%rip)    # 0x7db300
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241ace
leaq 0x2b3e8b(%rip), %rax    # 0x4f5957
jmp 0x241afd
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241ae2
leaq 0x1bed17(%rip), %rax    # 0x4007f7
jmp 0x241afd
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241af6
leaq 0x5a966(%rip), %rax     # 0x29c45a
jmp 0x241afd
leaq 0xb8d49(%rip), %rax     # 0x2fa846
movq %rax, 0x599804(%rip)    # 0x7db308
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241b57
leaq 0x2b69e1(%rip), %rax    # 0x4f8536
jmp 0x241b86
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241b6b
leaq 0x1c0cd1(%rip), %rax    # 0x40283a
jmp 0x241b86
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241b7f
leaq 0x5a8dd(%rip), %rax     # 0x29c45a
jmp 0x241b86
leaq 0xbb152(%rip), %rax     # 0x2fccd8
movq %rax, 0x599783(%rip)    # 0x7db310
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241be0
leaq 0x2ba7f4(%rip), %rax    # 0x4fc3d2
jmp 0x241c0f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241bf4
leaq 0x1c3441(%rip), %rax    # 0x405033
jmp 0x241c0f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241c08
leaq 0x5a854(%rip), %rax     # 0x29c45a
jmp 0x241c0f
leaq 0xbe214(%rip), %rax     # 0x2ffe23
movq %rax, 0x599702(%rip)    # 0x7db318
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241c69
leaq 0x2ca0ff(%rip), %rax    # 0x50bd66
jmp 0x241c98
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241c7d
leaq 0x1ce96c(%rip), %rax    # 0x4105e7
jmp 0x241c98
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241c91
leaq 0x594cf(%rip), %rax     # 0x29b15e
jmp 0x241c98
leaq 0xcb399(%rip), %rax     # 0x30d031
movq %rax, 0x599681(%rip)    # 0x7db320
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_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 0x5c8fdb
testl %eax, %eax
je 0x241cf2
leaq 0x2cbb16(%rip), %rax    # 0x50d806
jmp 0x241d21
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241d06
leaq 0x1d01d7(%rip), %rax    # 0x411edb
jmp 0x241d21
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241d1a
leaq 0x59446(%rip), %rax     # 0x29b15e
jmp 0x241d21
leaq 0xcd0ea(%rip), %rax     # 0x30ee0b
movq %rax, 0x599600(%rip)    # 0x7db328
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_16_pointer = parasail_sg_qb_db_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_16_pointer = parasail_sg_qb_db_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_16_pointer = parasail_sg_qb_db_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_16_pointer = parasail_sg_qb_db_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_16_pointer = parasail_sg_qb_db_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_striped_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x241d7b
leaq 0x2ce6c2(%rip), %rax    # 0x51043b
jmp 0x241daa
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241d8f
leaq 0x1d20ab(%rip), %rax    # 0x413e38
jmp 0x241daa
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241da3
leaq 0x593bd(%rip), %rax     # 0x29b15e
jmp 0x241daa
leaq 0xcf3b6(%rip), %rax     # 0x311160
movq %rax, 0x59957f(%rip)    # 0x7db330
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_striped_8_pointer = parasail_sg_qb_db_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_striped_8_pointer = parasail_sg_qb_db_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_striped_8_pointer = parasail_sg_qb_db_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_striped_8_pointer = parasail_sg_qb_db_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_striped_8_pointer = parasail_sg_qb_db_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_striped_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x241e04
leaq 0x2d2734(%rip), %rax    # 0x514536
jmp 0x241e33
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241e18
leaq 0x1d4998(%rip), %rax    # 0x4167ae
jmp 0x241e33
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241e2c
leaq 0x59334(%rip), %rax     # 0x29b15e
jmp 0x241e33
leaq 0xd2581(%rip), %rax     # 0x3143b4
movq %rax, 0x5994fe(%rip)    # 0x7db338
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_diag_64_pointer = parasail_sg_qb_db_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_diag_64_pointer = parasail_sg_qb_db_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_diag_64_pointer = parasail_sg_qb_db_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_diag_64_pointer = parasail_sg_qb_db_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_diag_64_pointer = parasail_sg_qb_db_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_diag_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x241e8d
leaq 0x2bc83d(%rip), %rax    # 0x4fe6c8
jmp 0x241ebc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241ea1
leaq 0x1c4f4f(%rip), %rax    # 0x406dee
jmp 0x241ebc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241eb5
leaq 0x592ab(%rip), %rax     # 0x29b15e
jmp 0x241ebc
leaq 0xc0433(%rip), %rax     # 0x3022ef
movq %rax, 0x59947d(%rip)    # 0x7db340
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_diag_32_pointer = parasail_sg_qb_db_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_diag_32_pointer = parasail_sg_qb_db_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_diag_32_pointer = parasail_sg_qb_db_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_diag_32_pointer = parasail_sg_qb_db_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_diag_32_pointer = parasail_sg_qb_db_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_diag_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x241f16
leaq 0x2beb50(%rip), %rax    # 0x500a64
jmp 0x241f45
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241f2a
leaq 0x1c6aae(%rip), %rax    # 0x4089d6
jmp 0x241f45
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241f3e
leaq 0x59222(%rip), %rax     # 0x29b15e
jmp 0x241f45
leaq 0xc24a3(%rip), %rax     # 0x3043e8
movq %rax, 0x5993fc(%rip)    # 0x7db348
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_diag_16_pointer = parasail_sg_qb_db_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_diag_16_pointer = parasail_sg_qb_db_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_diag_16_pointer = parasail_sg_qb_db_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_diag_16_pointer = parasail_sg_qb_db_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_diag_16_pointer = parasail_sg_qb_db_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_diag_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x241f9f
leaq 0x2c1f4c(%rip), %rax    # 0x503ee9
jmp 0x241fce
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x241fb3
leaq 0x1c8d41(%rip), %rax    # 0x40acf2
jmp 0x241fce
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x241fc7
leaq 0x59199(%rip), %rax     # 0x29b15e
jmp 0x241fce
leaq 0xc4996(%rip), %rax     # 0x306964
movq %rax, 0x59937b(%rip)    # 0x7db350
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_table_diag_8_pointer = parasail_sg_qb_db_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_diag_8_pointer = parasail_sg_qb_db_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_diag_8_pointer = parasail_sg_qb_db_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_diag_8_pointer = parasail_sg_qb_db_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_diag_8_pointer = parasail_sg_qb_db_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_diag_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x242028
leaq 0x2c6f69(%rip), %rax    # 0x508f8f
jmp 0x242057
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x24203c
leaq 0x1cc0a7(%rip), %rax    # 0x40e0e1
jmp 0x242057
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x242050
leaq 0x59110(%rip), %rax     # 0x29b15e
jmp 0x242057
leaq 0xc8311(%rip), %rax     # 0x30a368
movq %rax, 0x5992fa(%rip)    # 0x7db358
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_table_scan_64_pointer = parasail_sg_qb_db_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_table_scan_64_pointer = parasail_sg_qb_db_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_table_scan_64_pointer = parasail_sg_qb_db_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_table_scan_64_pointer = parasail_sg_qb_db_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_table_scan_64_pointer = parasail_sg_qb_db_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_table_scan_64_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x2420b1
leaq 0x2d574b(%rip), %rax    # 0x5177fa
jmp 0x2420e0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2420c5
leaq 0x1d7e8f(%rip), %rax    # 0x419f52
jmp 0x2420e0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2420d9
leaq 0x5a383(%rip), %rax     # 0x29c45a
jmp 0x2420e0
leaq 0xd5e6e(%rip), %rax     # 0x317f4e
movq %rax, 0x599279(%rip)    # 0x7db360
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_table_scan_32_pointer = parasail_sg_qb_db_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_table_scan_32_pointer = parasail_sg_qb_db_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_table_scan_32_pointer = parasail_sg_qb_db_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_table_scan_32_pointer = parasail_sg_qb_db_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_table_scan_32_pointer = parasail_sg_qb_db_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_table_scan_32_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x24213a
leaq 0x2d8d9c(%rip), %rax    # 0x51aed4
jmp 0x242169
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x24214e
leaq 0x1db2fe(%rip), %rax    # 0x41d44a
jmp 0x242169
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x242162
leaq 0x5a2fa(%rip), %rax     # 0x29c45a
jmp 0x242169
leaq 0xd9bbe(%rip), %rax     # 0x31bd27
movq %rax, 0x5991f8(%rip)    # 0x7db368
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_db_stats_table_scan_16_pointer = parasail_sg_qb_db_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_table_scan_16_pointer = parasail_sg_qb_db_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_table_scan_16_pointer = parasail_sg_qb_db_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_table_scan_16_pointer = parasail_sg_qb_db_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_table_scan_16_pointer = parasail_sg_qb_db_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_table_scan_16_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_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 0x5c8fdb
testl %eax, %eax
je 0x2421c3
leaq 0x2dd47c(%rip), %rax    # 0x51f63d
jmp 0x2421f2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2421d7
leaq 0x1def25(%rip), %rax    # 0x4210fa
jmp 0x2421f2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2421eb
leaq 0x5a271(%rip), %rax     # 0x29c45a
jmp 0x2421f2
leaq 0xde047(%rip), %rax     # 0x320239
movq %rax, 0x599177(%rip)    # 0x7db370
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