LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21ef93
leaq 0x2c4b39(%rip), %rax    # 0x4e3aca
jmp 0x21efc2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21efa7
leaq 0x1d1c45(%rip), %rax    # 0x3f0bea
jmp 0x21efc2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21efbb
leaq 0x7aafe(%rip), %rax     # 0x299ab7
jmp 0x21efc2
leaq 0xe329e(%rip), %rax     # 0x302260
movq %rax, 0x5844c7(%rip)    # 0x7a3490
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f01c
leaq 0x2c7144(%rip), %rax    # 0x4e615e
jmp 0x21f04b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f030
leaq 0x1d3b94(%rip), %rax    # 0x3f2bc2
jmp 0x21f04b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f044
leaq 0x7aa75(%rip), %rax     # 0x299ab7
jmp 0x21f04b
leaq 0xe55b6(%rip), %rax     # 0x304601
movq %rax, 0x584446(%rip)    # 0x7a3498
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f0a5
leaq 0x2b22bc(%rip), %rax    # 0x4d135f
jmp 0x21f0d4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f0b9
leaq 0x1c4b74(%rip), %rax    # 0x3e3c2b
jmp 0x21f0d4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f0cd
leaq 0x7a9ec(%rip), %rax     # 0x299ab7
jmp 0x21f0d4
leaq 0xd5225(%rip), %rax     # 0x2f42f9
movq %rax, 0x5843c5(%rip)    # 0x7a34a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f12e
leaq 0x2b49f7(%rip), %rax    # 0x4d3b23
jmp 0x21f15d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f142
leaq 0x1c6863(%rip), %rax    # 0x3e59a3
jmp 0x21f15d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f156
leaq 0x7a963(%rip), %rax     # 0x299ab7
jmp 0x21f15d
leaq 0xd72a3(%rip), %rax     # 0x2f6400
movq %rax, 0x584344(%rip)    # 0x7a34a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f1b7
leaq 0x2b7df2(%rip), %rax    # 0x4d6fa7
jmp 0x21f1e6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f1cb
leaq 0x1c8c18(%rip), %rax    # 0x3e7de1
jmp 0x21f1e6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f1df
leaq 0x7a8da(%rip), %rax     # 0x299ab7
jmp 0x21f1e6
leaq 0xd98ff(%rip), %rax     # 0x2f8ae5
movq %rax, 0x5842c3(%rip)    # 0x7a34b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f240
leaq 0x2bd2ac(%rip), %rax    # 0x4dc4ea
jmp 0x21f26f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f254
leaq 0x1cbfd8(%rip), %rax    # 0x3eb22a
jmp 0x21f26f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f268
leaq 0x7a851(%rip), %rax     # 0x299ab7
jmp 0x21f26f
leaq 0xdd0fc(%rip), %rax     # 0x2fc36b
movq %rax, 0x584242(%rip)    # 0x7a34b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f2c9
leaq 0x2cab1f(%rip), %rax    # 0x4e9de6
jmp 0x21f2f8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f2dd
leaq 0x1d72dc(%rip), %rax    # 0x3f65b7
jmp 0x21f2f8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f2f1
leaq 0x7b646(%rip), %rax     # 0x29a935
jmp 0x21f2f8
leaq 0xe89aa(%rip), %rax     # 0x307ca2
movq %rax, 0x5841c1(%rip)    # 0x7a34c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f352
leaq 0x2ce5f2(%rip), %rax    # 0x4ed942
jmp 0x21f381
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f366
leaq 0x1da773(%rip), %rax    # 0x3f9ad7
jmp 0x21f381
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f37a
leaq 0x7b5bd(%rip), %rax     # 0x29a935
jmp 0x21f381
leaq 0xec42b(%rip), %rax     # 0x30b7ac
movq %rax, 0x584140(%rip)    # 0x7a34c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f3db
leaq 0x2d23bb(%rip), %rax    # 0x4f1794
jmp 0x21f40a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f3ef
leaq 0x1dde6c(%rip), %rax    # 0x3fd259
jmp 0x21f40a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f403
leaq 0x7b534(%rip), %rax     # 0x29a935
jmp 0x21f40a
leaq 0xeff81(%rip), %rax     # 0x30f38b
movq %rax, 0x5840bf(%rip)    # 0x7a34d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f464
leaq 0x2d660a(%rip), %rax    # 0x4f5a6c
jmp 0x21f493
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f478
leaq 0x1e1dcc(%rip), %rax    # 0x401242
jmp 0x21f493
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f48c
leaq 0x7b4ab(%rip), %rax     # 0x29a935
jmp 0x21f493
leaq 0xf443e(%rip), %rax     # 0x3138d1
movq %rax, 0x58403e(%rip)    # 0x7a34d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f4ed
leaq 0x2f1111(%rip), %rax    # 0x5105fc
jmp 0x21f51c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f501
leaq 0x1f6c6f(%rip), %rax    # 0x41616e
jmp 0x21f51c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f515
leaq 0x7a5a4(%rip), %rax     # 0x299ab7
jmp 0x21f51c
leaq 0x10b006(%rip), %rax    # 0x32a522
movq %rax, 0x583fbd(%rip)    # 0x7a34e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f576
leaq 0x2f49bb(%rip), %rax    # 0x513f2f
jmp 0x21f5a5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f58a
leaq 0x1f9f12(%rip), %rax    # 0x41949a
jmp 0x21f5a5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f59e
leaq 0x7a51b(%rip), %rax     # 0x299ab7
jmp 0x21f5a5
leaq 0x10e968(%rip), %rax    # 0x32df0d
movq %rax, 0x583f3c(%rip)    # 0x7a34e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f5ff
leaq 0x2f9069(%rip), %rax    # 0x518666
jmp 0x21f62e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f613
leaq 0x1fd878(%rip), %rax    # 0x41ce89
jmp 0x21f62e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f627
leaq 0x7a492(%rip), %rax     # 0x299ab7
jmp 0x21f62e
leaq 0x1125f4(%rip), %rax    # 0x331c22
movq %rax, 0x583ebb(%rip)    # 0x7a34f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f688
leaq 0x2fdada(%rip), %rax    # 0x51d160
jmp 0x21f6b7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f69c
leaq 0x202563(%rip), %rax    # 0x421bfd
jmp 0x21f6b7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f6b0
leaq 0x7a409(%rip), %rax     # 0x299ab7
jmp 0x21f6b7
leaq 0x1176aa(%rip), %rax    # 0x336d61
movq %rax, 0x583e3a(%rip)    # 0x7a34f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f711
leaq 0x2da9e2(%rip), %rax    # 0x4fa0f1
jmp 0x21f740
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f725
leaq 0x1e58d5(%rip), %rax    # 0x404ff8
jmp 0x21f740
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f739
leaq 0x7a380(%rip), %rax     # 0x299ab7
jmp 0x21f740
leaq 0xf862e(%rip), %rax     # 0x317d6e
movq %rax, 0x583db9(%rip)    # 0x7a3500
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f79a
leaq 0x2df441(%rip), %rax    # 0x4febd9
jmp 0x21f7c9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f7ae
leaq 0x1e9396(%rip), %rax    # 0x408b42
jmp 0x21f7c9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f7c2
leaq 0x7a2f7(%rip), %rax     # 0x299ab7
jmp 0x21f7c9
leaq 0xfc722(%rip), %rax     # 0x31beeb
movq %rax, 0x583d38(%rip)    # 0x7a3508
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f823
leaq 0x2e47bf(%rip), %rax    # 0x503fe0
jmp 0x21f852
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f837
leaq 0x1ed544(%rip), %rax    # 0x40cd79
jmp 0x21f852
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f84b
leaq 0x7a26e(%rip), %rax     # 0x299ab7
jmp 0x21f852
leaq 0x100bd3(%rip), %rax    # 0x320425
movq %rax, 0x583cb7(%rip)    # 0x7a3510
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f8ac
leaq 0x2eb955(%rip), %rax    # 0x50b1ff
jmp 0x21f8db
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f8c0
leaq 0x1f26c8(%rip), %rax    # 0x411f86
jmp 0x21f8db
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f8d4
leaq 0x7a1e5(%rip), %rax     # 0x299ab7
jmp 0x21f8db
leaq 0x106419(%rip), %rax    # 0x325cf4
movq %rax, 0x583c36(%rip)    # 0x7a3518
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f935
leaq 0x300bc0(%rip), %rax    # 0x5204f3
jmp 0x21f964
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f949
leaq 0x205365(%rip), %rax    # 0x424cac
jmp 0x21f964
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f95d
leaq 0x7afda(%rip), %rax     # 0x29a935
jmp 0x21f964
leaq 0x11a8b0(%rip), %rax    # 0x33a214
movq %rax, 0x583bb5(%rip)    # 0x7a3520
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21f9be
leaq 0x3029d0(%rip), %rax    # 0x52238c
jmp 0x21f9ed
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21f9d2
leaq 0x206d0b(%rip), %rax    # 0x4266db
jmp 0x21f9ed
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21f9e6
leaq 0x7af51(%rip), %rax     # 0x29a935
jmp 0x21f9ed
leaq 0x11c4cc(%rip), %rax    # 0x33beb9
movq %rax, 0x583b34(%rip)    # 0x7a3528
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21fa47
leaq 0x30461d(%rip), %rax    # 0x524062
jmp 0x21fa76
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fa5b
leaq 0x20864b(%rip), %rax    # 0x4280a4
jmp 0x21fa76
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21fa6f
leaq 0x7aec8(%rip), %rax     # 0x29a935
jmp 0x21fa76
leaq 0x11df2c(%rip), %rax    # 0x33d9a2
movq %rax, 0x583ab3(%rip)    # 0x7a3530
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x594f9c
testl %eax, %eax
je 0x21fad0
leaq 0x306854(%rip), %rax    # 0x526322
jmp 0x21faff
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fae4
leaq 0x20a268(%rip), %rax    # 0x429d4a
jmp 0x21faff
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21faf8
leaq 0x7ae3f(%rip), %rax     # 0x29a935
jmp 0x21faff
leaq 0x11fd9a(%rip), %rax    # 0x33f899
movq %rax, 0x583a32(%rip)    # 0x7a3538
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