LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22532d
leaq 0x2d92df(%rip), %rax    # 0x4fe60a
jmp 0x22535c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225341
leaq 0x1e19f1(%rip), %rax    # 0x406d30
jmp 0x22535c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225355
leaq 0x75d4d(%rip), %rax     # 0x29b0a0
jmp 0x22535c
leaq 0xdced5(%rip), %rax     # 0x302231
movq %rax, 0x5b459d(%rip)    # 0x7d9900
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2253b6
leaq 0x2db5f2(%rip), %rax    # 0x5009a6
jmp 0x2253e5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2253ca
leaq 0x1e3550(%rip), %rax    # 0x408918
jmp 0x2253e5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2253de
leaq 0x75cc4(%rip), %rax     # 0x29b0a0
jmp 0x2253e5
leaq 0xdef45(%rip), %rax     # 0x30432a
movq %rax, 0x5b451c(%rip)    # 0x7d9908
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22543f
leaq 0x2de9ee(%rip), %rax    # 0x503e2b
jmp 0x22546e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225453
leaq 0x1e57e3(%rip), %rax    # 0x40ac34
jmp 0x22546e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225467
leaq 0x75c3b(%rip), %rax     # 0x29b0a0
jmp 0x22546e
leaq 0xe1438(%rip), %rax     # 0x3068a6
movq %rax, 0x5b449b(%rip)    # 0x7d9910
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2254c8
leaq 0x2e3a0b(%rip), %rax    # 0x508ed1
jmp 0x2254f7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2254dc
leaq 0x1e8b49(%rip), %rax    # 0x40e023
jmp 0x2254f7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2254f0
leaq 0x75bb2(%rip), %rax     # 0x29b0a0
jmp 0x2254f7
leaq 0xe4db3(%rip), %rax     # 0x30a2aa
movq %rax, 0x5b441a(%rip)    # 0x7d9918
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225551
leaq 0x2f21ed(%rip), %rax    # 0x51773c
jmp 0x225580
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225565
leaq 0x1f4931(%rip), %rax    # 0x419e94
jmp 0x225580
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225579
leaq 0x76e25(%rip), %rax     # 0x29c39c
jmp 0x225580
leaq 0xf2910(%rip), %rax     # 0x317e90
movq %rax, 0x5b4399(%rip)    # 0x7d9920
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2255da
leaq 0x2f583e(%rip), %rax    # 0x51ae16
jmp 0x225609
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2255ee
leaq 0x1f7da0(%rip), %rax    # 0x41d38c
jmp 0x225609
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225602
leaq 0x76d9c(%rip), %rax     # 0x29c39c
jmp 0x225609
leaq 0xf6660(%rip), %rax     # 0x31bc69
movq %rax, 0x5b4318(%rip)    # 0x7d9928
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225663
leaq 0x2f9f1e(%rip), %rax    # 0x51f57f
jmp 0x225692
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225677
leaq 0x1fb9c7(%rip), %rax    # 0x42103c
jmp 0x225692
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22568b
leaq 0x76d13(%rip), %rax     # 0x29c39c
jmp 0x225692
leaq 0xfaae9(%rip), %rax     # 0x32017b
movq %rax, 0x5b4297(%rip)    # 0x7d9930
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2256ec
leaq 0x2ff6ae(%rip), %rax    # 0x524d98
jmp 0x22571b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225700
leaq 0x20039b(%rip), %rax    # 0x425a99
jmp 0x22571b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225714
leaq 0x76c8a(%rip), %rax     # 0x29c39c
jmp 0x22571b
leaq 0x1001a8(%rip), %rax    # 0x3258c3
movq %rax, 0x5b4216(%rip)    # 0x7d9938
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225775
leaq 0x31858a(%rip), %rax    # 0x53dcfd
jmp 0x2257a4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225789
leaq 0x214ad8(%rip), %rax    # 0x43a25f
jmp 0x2257a4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22579d
leaq 0x75905(%rip), %rax     # 0x29b0a0
jmp 0x2257a4
leaq 0x11785c(%rip), %rax    # 0x33d000
movq %rax, 0x5b4195(%rip)    # 0x7d9940
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2257fe
leaq 0x31bb5c(%rip), %rax    # 0x541358
jmp 0x22582d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225812
leaq 0x217e73(%rip), %rax    # 0x43d683
jmp 0x22582d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225826
leaq 0x7587c(%rip), %rax     # 0x29b0a0
jmp 0x22582d
leaq 0x11b66a(%rip), %rax    # 0x340e97
movq %rax, 0x5b4114(%rip)    # 0x7d9948
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225887
leaq 0x320b7e(%rip), %rax    # 0x546403
jmp 0x2258b6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22589b
leaq 0x21bda6(%rip), %rax    # 0x44163f
jmp 0x2258b6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2258af
leaq 0x757f3(%rip), %rax     # 0x29b0a0
jmp 0x2258b6
leaq 0x11faf8(%rip), %rax    # 0x3453ae
movq %rax, 0x5b4093(%rip)    # 0x7d9950
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225910
leaq 0x326d1d(%rip), %rax    # 0x54c62b
jmp 0x22593f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225924
leaq 0x22113c(%rip), %rax    # 0x446a5e
jmp 0x22593f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225938
leaq 0x7576a(%rip), %rax     # 0x29b0a0
jmp 0x22593f
leaq 0x1259d6(%rip), %rax    # 0x34b315
movq %rax, 0x5b4012(%rip)    # 0x7d9958
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225999
leaq 0x3033e9(%rip), %rax    # 0x528d80
jmp 0x2259c8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2259ad
leaq 0x203cbd(%rip), %rax    # 0x429668
jmp 0x2259c8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2259c1
leaq 0x756e1(%rip), %rax     # 0x29b0a0
jmp 0x2259c8
leaq 0x104624(%rip), %rax    # 0x329fec
movq %rax, 0x5b3f91(%rip)    # 0x7d9960
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225a22
leaq 0x307a4b(%rip), %rax    # 0x52d46b
jmp 0x225a51
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225a36
leaq 0x207519(%rip), %rax    # 0x42cf4d
jmp 0x225a51
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225a4a
leaq 0x75658(%rip), %rax     # 0x29b0a0
jmp 0x225a51
leaq 0x1087ca(%rip), %rax    # 0x32e21b
movq %rax, 0x5b3f10(%rip)    # 0x7d9968
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225aab
leaq 0x30cd92(%rip), %rax    # 0x53283b
jmp 0x225ada
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225abf
leaq 0x20b5be(%rip), %rax    # 0x43107b
jmp 0x225ada
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225ad3
leaq 0x755cf(%rip), %rax     # 0x29b0a0
jmp 0x225ada
leaq 0x10cbb2(%rip), %rax    # 0x33268c
movq %rax, 0x5b3e8f(%rip)    # 0x7d9970
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225b34
leaq 0x313961(%rip), %rax    # 0x539493
jmp 0x225b63
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225b48
leaq 0x210832(%rip), %rax    # 0x436378
jmp 0x225b63
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225b5c
leaq 0x75546(%rip), %rax     # 0x29b0a0
jmp 0x225b63
leaq 0x112780(%rip), %rax    # 0x3382e3
movq %rax, 0x5b3e0e(%rip)    # 0x7d9978
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225bbd
leaq 0x3293b3(%rip), %rax    # 0x54ef6e
jmp 0x225bec
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225bd1
leaq 0x223d03(%rip), %rax    # 0x4498d2
jmp 0x225bec
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225be5
leaq 0x767b9(%rip), %rax     # 0x29c39c
jmp 0x225bec
leaq 0x128e82(%rip), %rax    # 0x34ea6e
movq %rax, 0x5b3d8d(%rip)    # 0x7d9980
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225c46
leaq 0x32aed8(%rip), %rax    # 0x550b1c
jmp 0x225c75
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225c5a
leaq 0x2257f2(%rip), %rax    # 0x44b44a
jmp 0x225c75
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225c6e
leaq 0x76730(%rip), %rax     # 0x29c39c
jmp 0x225c75
leaq 0x12ae62(%rip), %rax    # 0x350ad7
movq %rax, 0x5b3d0c(%rip)    # 0x7d9988
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225ccf
leaq 0x32d810(%rip), %rax    # 0x5534dd
jmp 0x225cfe
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225ce3
leaq 0x2275f0(%rip), %rax    # 0x44d2d1
jmp 0x225cfe
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225cf7
leaq 0x766a7(%rip), %rax     # 0x29c39c
jmp 0x225cfe
leaq 0x12d14f(%rip), %rax    # 0x352e4d
movq %rax, 0x5b3c8b(%rip)    # 0x7d9990
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225d58
leaq 0x3314ab(%rip), %rax    # 0x557201
jmp 0x225d87
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225d6c
leaq 0x229b42(%rip), %rax    # 0x44f8ac
jmp 0x225d87
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225d80
leaq 0x7661e(%rip), %rax     # 0x29c39c
jmp 0x225d87
leaq 0x12ffa1(%rip), %rax    # 0x355d28
movq %rax, 0x5b3c0a(%rip)    # 0x7d9998
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225de1
leaq 0x3417a9(%rip), %rax    # 0x567588
jmp 0x225e10
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225df5
leaq 0x235538(%rip), %rax    # 0x45b32b
jmp 0x225e10
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225e09
leaq 0x75299(%rip), %rax     # 0x29b0a0
jmp 0x225e10
leaq 0x13d592(%rip), %rax    # 0x3633a2
movq %rax, 0x5b3b89(%rip)    # 0x7d99a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x225e6a
leaq 0x342fe8(%rip), %rax    # 0x568e50
jmp 0x225e99
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225e7e
leaq 0x236d2d(%rip), %rax    # 0x45cba9
jmp 0x225e99
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225e92
leaq 0x75210(%rip), %rax     # 0x29b0a0
jmp 0x225e99
leaq 0x13f263(%rip), %rax    # 0x3650fc
movq %rax, 0x5b3b08(%rip)    # 0x7d99a8
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