LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de0db
leaq 0x2b44a7(%rip), %rax    # 0x492580
jmp 0x1de10a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de0ef
leaq 0x1bdead(%rip), %rax    # 0x39bf9a
jmp 0x1de10a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de103
leaq 0x5e806(%rip), %rax     # 0x23c907
jmp 0x1de10a
leaq 0xb4e25(%rip), %rax     # 0x292f2f
movq %rax, 0x55fd5f(%rip)    # 0x73de70
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_striped_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de164
leaq 0x2b764b(%rip), %rax    # 0x4957ad
jmp 0x1de193
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de178
leaq 0x1c10fc(%rip), %rax    # 0x39f272
jmp 0x1de193
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de18c
leaq 0x5e77d(%rip), %rax     # 0x23c907
jmp 0x1de193
leaq 0xb85de(%rip), %rax     # 0x296771
movq %rax, 0x55fcde(%rip)    # 0x73de78
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de1ed
leaq 0x29d79d(%rip), %rax    # 0x47b988
jmp 0x1de21c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de201
leaq 0x1a8c9c(%rip), %rax    # 0x386e9b
jmp 0x1de21c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de215
leaq 0x5e6f4(%rip), %rax     # 0x23c907
jmp 0x1de21c
leaq 0x9cb37(%rip), %rax     # 0x27ad53
movq %rax, 0x55fc5d(%rip)    # 0x73de80
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de276
leaq 0x2a0e5d(%rip), %rax    # 0x47f0d1
jmp 0x1de2a5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de28a
leaq 0x1ac18d(%rip), %rax    # 0x38a415
jmp 0x1de2a5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de29e
leaq 0x5e66b(%rip), %rax     # 0x23c907
jmp 0x1de2a5
leaq 0xa07a4(%rip), %rax     # 0x27ea49
movq %rax, 0x55fbdc(%rip)    # 0x73de88
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de2ff
leaq 0x2a4d39(%rip), %rax    # 0x483036
jmp 0x1de32e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de313
leaq 0x1af7f3(%rip), %rax    # 0x38db04
jmp 0x1de32e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de327
leaq 0x5e5e2(%rip), %rax     # 0x23c907
jmp 0x1de32e
leaq 0xa41a7(%rip), %rax     # 0x2824d5
movq %rax, 0x55fb5b(%rip)    # 0x73de90
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_diag_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de388
leaq 0x2a9adc(%rip), %rax    # 0x487e62
jmp 0x1de3b7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de39c
leaq 0x1b372c(%rip), %rax    # 0x391ac6
jmp 0x1de3b7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de3b0
leaq 0x5e559(%rip), %rax     # 0x23c907
jmp 0x1de3b7
leaq 0xa8cce(%rip), %rax     # 0x287085
movq %rax, 0x55fada(%rip)    # 0x73de98
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_db_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de411
leaq 0x2bb3e3(%rip), %rax    # 0x4997f2
jmp 0x1de440
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de425
leaq 0x1c356f(%rip), %rax    # 0x3a1992
jmp 0x1de440
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de439
leaq 0x5f53e(%rip), %rax     # 0x23d975
jmp 0x1de440
leaq 0xbc5f6(%rip), %rax     # 0x29aa36
movq %rax, 0x55fa59(%rip)    # 0x73dea0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_db_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de49a
leaq 0x2bd2e1(%rip), %rax    # 0x49b779
jmp 0x1de4c9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de4ae
leaq 0x1c51b9(%rip), %rax    # 0x3a3665
jmp 0x1de4c9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de4c2
leaq 0x5f4b5(%rip), %rax     # 0x23d975
jmp 0x1de4c9
leaq 0xbe6f6(%rip), %rax     # 0x29cbbf
movq %rax, 0x55f9d8(%rip)    # 0x73dea8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_db_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de523
leaq 0x2bf448(%rip), %rax    # 0x49d969
jmp 0x1de552
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de537
leaq 0x1c6fef(%rip), %rax    # 0x3a5524
jmp 0x1de552
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de54b
leaq 0x5f42c(%rip), %rax     # 0x23d975
jmp 0x1de552
leaq 0xc0675(%rip), %rax     # 0x29ebc7
movq %rax, 0x55f957(%rip)    # 0x73deb0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_db_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_scan_8_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de5ac
leaq 0x2c1a52(%rip), %rax    # 0x49fffc
jmp 0x1de5db
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de5c0
leaq 0x1c90da(%rip), %rax    # 0x3a7698
jmp 0x1de5db
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de5d4
leaq 0x5f3a3(%rip), %rax     # 0x23d975
jmp 0x1de5db
leaq 0xc2b94(%rip), %rax     # 0x2a116f
movq %rax, 0x55f8d6(%rip)    # 0x73deb8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_db_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de635
leaq 0x2d3177(%rip), %rax    # 0x4b17aa
jmp 0x1de664
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de649
leaq 0x1d59dc(%rip), %rax    # 0x3b4023
jmp 0x1de664
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de65d
leaq 0x5e2ac(%rip), %rax     # 0x23c907
jmp 0x1de664
leaq 0xd1198(%rip), %rax     # 0x2af7fc
movq %rax, 0x55f855(%rip)    # 0x73dec0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_db_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de6be
leaq 0x2d51f5(%rip), %rax    # 0x4b38b1
jmp 0x1de6ed
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de6d2
leaq 0x1d78d1(%rip), %rax    # 0x3b5fa1
jmp 0x1de6ed
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de6e6
leaq 0x5e223(%rip), %rax     # 0x23c907
jmp 0x1de6ed
leaq 0xd343f(%rip), %rax     # 0x2b1b2c
movq %rax, 0x55f7d4(%rip)    # 0x73dec8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_db_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de747
leaq 0x2d7513(%rip), %rax    # 0x4b5c58
jmp 0x1de776
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de75b
leaq 0x1d98db(%rip), %rax    # 0x3b8034
jmp 0x1de776
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de76f
leaq 0x5e19a(%rip), %rax     # 0x23c907
jmp 0x1de776
leaq 0xd5547(%rip), %rax     # 0x2b3cbd
movq %rax, 0x55f753(%rip)    # 0x73ded0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_db_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_striped_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de7d0
leaq 0x2d9e17(%rip), %rax    # 0x4b85e5
jmp 0x1de7ff
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de7e4
leaq 0x1dbbc0(%rip), %rax    # 0x3ba3a2
jmp 0x1de7ff
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de7f8
leaq 0x5e111(%rip), %rax     # 0x23c907
jmp 0x1de7ff
leaq 0xd7a1d(%rip), %rax     # 0x2b621c
movq %rax, 0x55f6d2(%rip)    # 0x73ded8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_db_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_64_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de859
leaq 0x2c3ef9(%rip), %rax    # 0x4a2750
jmp 0x1de888
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de86d
leaq 0x1caf7f(%rip), %rax    # 0x3a97ea
jmp 0x1de888
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de881
leaq 0x5e088(%rip), %rax     # 0x23c907
jmp 0x1de888
leaq 0xc521c(%rip), %rax     # 0x2a3aa4
movq %rax, 0x55f651(%rip)    # 0x73dee0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_db_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_32_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de8e2
leaq 0x2c66c4(%rip), %rax    # 0x4a4fa4
jmp 0x1de911
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de8f6
leaq 0x1cce22(%rip), %rax    # 0x3ab716
jmp 0x1de911
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de90a
leaq 0x5dfff(%rip), %rax     # 0x23c907
jmp 0x1de911
leaq 0xc74e1(%rip), %rax     # 0x2a5df2
movq %rax, 0x55f5d0(%rip)    # 0x73dee8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_db_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_16_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de96b
leaq 0x2c9e22(%rip), %rax    # 0x4a878b
jmp 0x1de99a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1de97f
leaq 0x1cf3db(%rip), %rax    # 0x3add58
jmp 0x1de99a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1de993
leaq 0x5df76(%rip), %rax     # 0x23c907
jmp 0x1de99a
leaq 0xc9e12(%rip), %rax     # 0x2a87ac
movq %rax, 0x55f54f(%rip)    # 0x73def0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_db_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_db_table_diag_8_pointer = parasail_sg_qe_db;
    }
    return parasail_sg_qe_db_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1de9f4
leaq 0x2cf62e(%rip), %rax    # 0x4ae020
jmp 0x1dea23
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1dea08
leaq 0x1d2b0e(%rip), %rax    # 0x3b1514
jmp 0x1dea23
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1dea1c
leaq 0x5deed(%rip), %rax     # 0x23c907
jmp 0x1dea23
leaq 0xcdbca(%rip), %rax     # 0x2ac5ed
movq %rax, 0x55f4ce(%rip)    # 0x73def8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_scan_64_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1dea7d
leaq 0x2dda3e(%rip), %rax    # 0x4bc4b9
jmp 0x1deaac
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1dea91
leaq 0x1dfadc(%rip), %rax    # 0x3be56b
jmp 0x1deaac
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1deaa5
leaq 0x5eed2(%rip), %rax     # 0x23d975
jmp 0x1deaac
leaq 0xdbac4(%rip), %rax     # 0x2ba570
movq %rax, 0x55f44d(%rip)    # 0x73df00
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_scan_32_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1deb06
leaq 0x2e1834(%rip), %rax    # 0x4c0338
jmp 0x1deb35
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1deb1a
leaq 0x1e35c4(%rip), %rax    # 0x3c20dc
jmp 0x1deb35
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1deb2e
leaq 0x5ee49(%rip), %rax     # 0x23d975
jmp 0x1deb35
leaq 0xdff3e(%rip), %rax     # 0x2bea73
movq %rax, 0x55f3cc(%rip)    # 0x73df08
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_db_dispatch.c
// Function: parasail_sg_qe_db_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_db_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_db_stats_table_scan_16_pointer = parasail_sg_qe_db_scan;
    }
    return parasail_sg_qe_db_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1deb8f
leaq 0x2e55a3(%rip), %rax    # 0x4c4130
jmp 0x1debbe
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1deba3
leaq 0x1e6ff2(%rip), %rax    # 0x3c5b93
jmp 0x1debbe
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1debb7
leaq 0x5edc0(%rip), %rax     # 0x23d975
jmp 0x1debbe
leaq 0xe3e2e(%rip), %rax     # 0x2c29ec
movq %rax, 0x55f34b(%rip)    # 0x73df10
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