LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_diag_64_pointer = parasail_sg_qb_de_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d8ef1
leaq 0x283301(%rip), %rax    # 0x45c1f0
jmp 0x1d8f20
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8f05
leaq 0x190291(%rip), %rax    # 0x369194
jmp 0x1d8f20
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8f19
leaq 0x639d3(%rip), %rax     # 0x23c8ea
jmp 0x1d8f20
leaq 0x8019c(%rip), %rax     # 0x2590bc
movq %rax, 0x564a99(%rip)    # 0x73d9c0
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_diag_32_pointer = parasail_sg_qb_de_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d8f7a
leaq 0x28520a(%rip), %rax    # 0x45e182
jmp 0x1d8fa9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d8f8e
leaq 0x191d71(%rip), %rax    # 0x36acfd
jmp 0x1d8fa9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d8fa2
leaq 0x6394a(%rip), %rax     # 0x23c8ea
jmp 0x1d8fa9
leaq 0x820d6(%rip), %rax     # 0x25b07f
movq %rax, 0x564a18(%rip)    # 0x73d9c8
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_diag_16_pointer = parasail_sg_qb_de_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d9003
leaq 0x2876ea(%rip), %rax    # 0x4606eb
jmp 0x1d9032
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d9017
leaq 0x1939cf(%rip), %rax    # 0x36c9e4
jmp 0x1d9032
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d902b
leaq 0x638c1(%rip), %rax     # 0x23c8ea
jmp 0x1d9032
leaq 0x84056(%rip), %rax     # 0x25d088
movq %rax, 0x564997(%rip)    # 0x73d9d0
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_diag_8_pointer = parasail_sg_qb_de_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d908c
leaq 0x28a6f7(%rip), %rax    # 0x463781
jmp 0x1d90bb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d90a0
leaq 0x195db0(%rip), %rax    # 0x36ee4e
jmp 0x1d90bb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d90b4
leaq 0x63838(%rip), %rax     # 0x23c8ea
jmp 0x1d90bb
leaq 0x86c02(%rip), %rax     # 0x25fcbd
movq %rax, 0x564916(%rip)    # 0x73d9d8
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d9115
leaq 0x2950a6(%rip), %rax    # 0x46e1b9
jmp 0x1d9144
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d9129
leaq 0x1a06dd(%rip), %rax    # 0x379804
jmp 0x1d9144
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d913d
leaq 0x6481d(%rip), %rax     # 0x23d958
jmp 0x1d9144
leaq 0x9277d(%rip), %rax     # 0x26b8c1
movq %rax, 0x564895(%rip)    # 0x73d9e0
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d919e
leaq 0x2987c6(%rip), %rax    # 0x471962
jmp 0x1d91cd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d91b2
leaq 0x1a3cff(%rip), %rax    # 0x37ceaf
jmp 0x1d91cd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d91c6
leaq 0x64794(%rip), %rax     # 0x23d958
jmp 0x1d91cd
leaq 0x966d5(%rip), %rax     # 0x26f8a2
movq %rax, 0x564814(%rip)    # 0x73d9e8
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d9227
leaq 0x29ba6e(%rip), %rax    # 0x474c93
jmp 0x1d9256
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d923b
leaq 0x1a6fc1(%rip), %rax    # 0x3801fa
jmp 0x1d9256
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d924f
leaq 0x6470b(%rip), %rax     # 0x23d958
jmp 0x1d9256
leaq 0x99e1d(%rip), %rax     # 0x273073
movq %rax, 0x564793(%rip)    # 0x73d9f0
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d92b0
leaq 0x29ed19(%rip), %rax    # 0x477fc7
jmp 0x1d92df
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d92c4
leaq 0x1aa2e7(%rip), %rax    # 0x3835a9
jmp 0x1d92df
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d92d8
leaq 0x64682(%rip), %rax     # 0x23d958
jmp 0x1d92df
leaq 0x9d6f3(%rip), %rax     # 0x2769d2
movq %rax, 0x564712(%rip)    # 0x73d9f8
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d9339
leaq 0x2b2cd5(%rip), %rax    # 0x48c00c
jmp 0x1d9368
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d934d
leaq 0x1bc4c3(%rip), %rax    # 0x39580e
jmp 0x1d9368
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9361
leaq 0x6358b(%rip), %rax     # 0x23c8ea
jmp 0x1d9368
leaq 0xb286c(%rip), %rax     # 0x28bbd4
movq %rax, 0x564691(%rip)    # 0x73da00
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d93c2
leaq 0x2b6068(%rip), %rax    # 0x48f428
jmp 0x1d93f1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d93d6
leaq 0x1bf91d(%rip), %rax    # 0x398cf1
jmp 0x1d93f1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d93ea
leaq 0x63502(%rip), %rax     # 0x23c8ea
jmp 0x1d93f1
leaq 0xb6525(%rip), %rax     # 0x28f916
movq %rax, 0x564610(%rip)    # 0x73da08
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d944b
leaq 0x2b911a(%rip), %rax    # 0x492563
jmp 0x1d947a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d945f
leaq 0x1c2b20(%rip), %rax    # 0x39bf7d
jmp 0x1d947a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9473
leaq 0x63479(%rip), %rax     # 0x23c8ea
jmp 0x1d947a
leaq 0xb9a98(%rip), %rax     # 0x292f12
movq %rax, 0x56458f(%rip)    # 0x73da10
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d94d4
leaq 0x2bc2be(%rip), %rax    # 0x495790
jmp 0x1d9503
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d94e8
leaq 0x1c5d6f(%rip), %rax    # 0x39f255
jmp 0x1d9503
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d94fc
leaq 0x633f0(%rip), %rax     # 0x23c8ea
jmp 0x1d9503
leaq 0xbd251(%rip), %rax     # 0x296754
movq %rax, 0x56450e(%rip)    # 0x73da18
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d955d
leaq 0x2a2410(%rip), %rax    # 0x47b96b
jmp 0x1d958c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d9571
leaq 0x1ad90f(%rip), %rax    # 0x386e7e
jmp 0x1d958c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9585
leaq 0x63367(%rip), %rax     # 0x23c8ea
jmp 0x1d958c
leaq 0xa17aa(%rip), %rax     # 0x27ad36
movq %rax, 0x56448d(%rip)    # 0x73da20
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d95e6
leaq 0x2a5ad0(%rip), %rax    # 0x47f0b4
jmp 0x1d9615
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d95fa
leaq 0x1b0e00(%rip), %rax    # 0x38a3f8
jmp 0x1d9615
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d960e
leaq 0x632de(%rip), %rax     # 0x23c8ea
jmp 0x1d9615
leaq 0xa5417(%rip), %rax     # 0x27ea2c
movq %rax, 0x56440c(%rip)    # 0x73da28
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d966f
leaq 0x2a99ac(%rip), %rax    # 0x483019
jmp 0x1d969e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d9683
leaq 0x1b4466(%rip), %rax    # 0x38dae7
jmp 0x1d969e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9697
leaq 0x63255(%rip), %rax     # 0x23c8ea
jmp 0x1d969e
leaq 0xa8e1a(%rip), %rax     # 0x2824b8
movq %rax, 0x56438b(%rip)    # 0x73da30
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d96f8
leaq 0x2ae74f(%rip), %rax    # 0x487e45
jmp 0x1d9727
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d970c
leaq 0x1b839f(%rip), %rax    # 0x391aa9
jmp 0x1d9727
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9720
leaq 0x631cc(%rip), %rax     # 0x23c8ea
jmp 0x1d9727
leaq 0xad941(%rip), %rax     # 0x287068
movq %rax, 0x56430a(%rip)    # 0x73da38
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x1d9781
leaq 0x2c0056(%rip), %rax    # 0x4997d5
jmp 0x1d97b0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d9795
leaq 0x1c81e2(%rip), %rax    # 0x3a1975
jmp 0x1d97b0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d97a9
leaq 0x641b1(%rip), %rax     # 0x23d958
jmp 0x1d97b0
leaq 0xc1269(%rip), %rax     # 0x29aa19
movq %rax, 0x564289(%rip)    # 0x73da40
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x1d980a
leaq 0x2c1f54(%rip), %rax    # 0x49b75c
jmp 0x1d9839
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d981e
leaq 0x1c9e2c(%rip), %rax    # 0x3a3648
jmp 0x1d9839
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9832
leaq 0x64128(%rip), %rax     # 0x23d958
jmp 0x1d9839
leaq 0xc3369(%rip), %rax     # 0x29cba2
movq %rax, 0x564208(%rip)    # 0x73da48
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x1d9893
leaq 0x2c40bb(%rip), %rax    # 0x49d94c
jmp 0x1d98c2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d98a7
leaq 0x1cbc62(%rip), %rax    # 0x3a5507
jmp 0x1d98c2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d98bb
leaq 0x6409f(%rip), %rax     # 0x23d958
jmp 0x1d98c2
leaq 0xc52e8(%rip), %rax     # 0x29ebaa
movq %rax, 0x564187(%rip)    # 0x73da50
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x1d991c
leaq 0x2c66c5(%rip), %rax    # 0x49ffdf
jmp 0x1d994b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d9930
leaq 0x1cdd4d(%rip), %rax    # 0x3a767b
jmp 0x1d994b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9944
leaq 0x64016(%rip), %rax     # 0x23d958
jmp 0x1d994b
leaq 0xc7807(%rip), %rax     # 0x2a1152
movq %rax, 0x564106(%rip)    # 0x73da58
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d99a5
leaq 0x2d7dea(%rip), %rax    # 0x4b178d
jmp 0x1d99d4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d99b9
leaq 0x1da64f(%rip), %rax    # 0x3b4006
jmp 0x1d99d4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d99cd
leaq 0x62f1f(%rip), %rax     # 0x23c8ea
jmp 0x1d99d4
leaq 0xd5e0b(%rip), %rax     # 0x2af7df
movq %rax, 0x564085(%rip)    # 0x73da60
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x1d9a2e
leaq 0x2d9e68(%rip), %rax    # 0x4b3894
jmp 0x1d9a5d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d9a42
leaq 0x1dc544(%rip), %rax    # 0x3b5f84
jmp 0x1d9a5d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d9a56
leaq 0x62e96(%rip), %rax     # 0x23c8ea
jmp 0x1d9a5d
leaq 0xd80b2(%rip), %rax     # 0x2b1b0f
movq %rax, 0x564004(%rip)    # 0x73da68
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