LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_striped_32_pointer = parasail_sg_qe_de_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_striped_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x245caa
leaq 0x27ac8f(%rip), %rax    # 0x4c0937
jmp 0x245cd9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x245cbe
leaq 0x18c2a2(%rip), %rax    # 0x3d1f5e
jmp 0x245cd9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x245cd2
leaq 0x554b0(%rip), %rax     # 0x29b180
jmp 0x245cd9
leaq 0x7c89b(%rip), %rax     # 0x2c2574
movq %rax, 0x5959e8(%rip)    # 0x7db6c8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_striped_16_pointer = parasail_sg_qe_de_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_striped_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x245d33
leaq 0x27cd0d(%rip), %rax    # 0x4c2a3e
jmp 0x245d62
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x245d47
leaq 0x18db82(%rip), %rax    # 0x3d38c7
jmp 0x245d62
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x245d5b
leaq 0x55427(%rip), %rax     # 0x29b180
jmp 0x245d62
leaq 0x7e593(%rip), %rax     # 0x2c42f5
movq %rax, 0x595967(%rip)    # 0x7db6d0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_striped_8_pointer = parasail_sg_qe_de_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_striped_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x245dbc
leaq 0x27fbad(%rip), %rax    # 0x4c5967
jmp 0x245deb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x245dd0
leaq 0x18f865(%rip), %rax    # 0x3d5633
jmp 0x245deb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x245de4
leaq 0x5539e(%rip), %rax     # 0x29b180
jmp 0x245deb
leaq 0x80b0c(%rip), %rax     # 0x2c68f7
movq %rax, 0x5958e6(%rip)    # 0x7db6d8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x245e45
leaq 0x270503(%rip), %rax    # 0x4b6346
jmp 0x245e74
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x245e59
leaq 0x183491(%rip), %rax    # 0x3c92e8
jmp 0x245e74
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x245e6d
leaq 0x55315(%rip), %rax     # 0x29b180
jmp 0x245e74
leaq 0x7214d(%rip), %rax     # 0x2b7fc1
movq %rax, 0x595865(%rip)    # 0x7db6e0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x245ece
leaq 0x272156(%rip), %rax    # 0x4b8022
jmp 0x245efd
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x245ee2
leaq 0x184c82(%rip), %rax    # 0x3cab62
jmp 0x245efd
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x245ef6
leaq 0x5528c(%rip), %rax     # 0x29b180
jmp 0x245efd
leaq 0x73dd3(%rip), %rax     # 0x2b9cd0
movq %rax, 0x5957e4(%rip)    # 0x7db6e8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x245f57
leaq 0x274533(%rip), %rax    # 0x4ba488
jmp 0x245f86
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x245f6b
leaq 0x1867c9(%rip), %rax    # 0x3cc732
jmp 0x245f86
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x245f7f
leaq 0x55203(%rip), %rax     # 0x29b180
jmp 0x245f86
leaq 0x75bca(%rip), %rax     # 0x2bbb50
movq %rax, 0x595763(%rip)    # 0x7db6f0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_de_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_diag_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x245fe0
leaq 0x2773ff(%rip), %rax    # 0x4bd3dd
jmp 0x24600f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x245ff4
leaq 0x188abb(%rip), %rax    # 0x3ceaad
jmp 0x24600f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x246008
leaq 0x5517a(%rip), %rax     # 0x29b180
jmp 0x24600f
leaq 0x784fd(%rip), %rax     # 0x2be50c
movq %rax, 0x5956e2(%rip)    # 0x7db6f8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_scan_64_pointer = parasail_sg_qe_de_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_scan_64_pointer = parasail_sg_qe_de_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_scan_64_pointer = parasail_sg_qe_de_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_scan_64_pointer = parasail_sg_qe_de_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_scan_64_pointer = parasail_sg_qe_de_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_scan_64_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x246069
leaq 0x2820e0(%rip), %rax    # 0x4c8147
jmp 0x246098
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x24607d
leaq 0x192548(%rip), %rax    # 0x3d85c3
jmp 0x246098
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x246091
leaq 0x563ed(%rip), %rax     # 0x29c47c
jmp 0x246098
leaq 0x83c8c(%rip), %rax     # 0x2c9d24
movq %rax, 0x595661(%rip)    # 0x7db700
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_scan_32_pointer = parasail_sg_qe_de_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_scan_32_pointer = parasail_sg_qe_de_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_scan_32_pointer = parasail_sg_qe_de_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_scan_32_pointer = parasail_sg_qe_de_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_scan_32_pointer = parasail_sg_qe_de_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_scan_32_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2460f2
leaq 0x284fe5(%rip), %rax    # 0x4cb0d5
jmp 0x246121
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x246106
leaq 0x195572(%rip), %rax    # 0x3db676
jmp 0x246121
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x24611a
leaq 0x56364(%rip), %rax     # 0x29c47c
jmp 0x246121
leaq 0x87530(%rip), %rax     # 0x2cd651
movq %rax, 0x5955e0(%rip)    # 0x7db708
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_scan_16_pointer = parasail_sg_qe_de_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_scan_16_pointer = parasail_sg_qe_de_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_scan_16_pointer = parasail_sg_qe_de_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_scan_16_pointer = parasail_sg_qe_de_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_scan_16_pointer = parasail_sg_qe_de_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_scan_16_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x24617b
leaq 0x288728(%rip), %rax    # 0x4ce8a1
jmp 0x2461aa
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x24618f
leaq 0x198935(%rip), %rax    # 0x3deac2
jmp 0x2461aa
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2461a3
leaq 0x562db(%rip), %rax     # 0x29c47c
jmp 0x2461aa
leaq 0x8b0d9(%rip), %rax     # 0x2d1283
movq %rax, 0x59555f(%rip)    # 0x7db710
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x246204
leaq 0x28c999(%rip), %rax    # 0x4d2b9b
jmp 0x246233
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x246218
leaq 0x19c135(%rip), %rax    # 0x3e234b
jmp 0x246233
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x24622c
leaq 0x56252(%rip), %rax     # 0x29c47c
jmp 0x246233
leaq 0x8f5d3(%rip), %rax     # 0x2d5806
movq %rax, 0x5954de(%rip)    # 0x7db718
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x24628d
leaq 0x29f9c0(%rip), %rax    # 0x4e5c4b
jmp 0x2462bc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2462a1
leaq 0x1ad0e9(%rip), %rax    # 0x3f3388
jmp 0x2462bc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2462b5
leaq 0x54ecd(%rip), %rax     # 0x29b180
jmp 0x2462bc
leaq 0xa37fd(%rip), %rax     # 0x2e9ab9
movq %rax, 0x59545d(%rip)    # 0x7db720
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x246316
leaq 0x2a2673(%rip), %rax    # 0x4e8987
jmp 0x246345
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x24632a
leaq 0x1afee0(%rip), %rax    # 0x3f6208
jmp 0x246345
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x24633e
leaq 0x54e44(%rip), %rax     # 0x29b180
jmp 0x246345
leaq 0xa7133(%rip), %rax     # 0x2ed478
movq %rax, 0x5953dc(%rip)    # 0x7db728
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x24639f
leaq 0x2a5d80(%rip), %rax    # 0x4ec11d
jmp 0x2463ce
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2463b3
leaq 0x1b3068(%rip), %rax    # 0x3f9419
jmp 0x2463ce
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2463c7
leaq 0x54dbb(%rip), %rax     # 0x29b180
jmp 0x2463ce
leaq 0xaa7df(%rip), %rax     # 0x2f0bad
movq %rax, 0x59535b(%rip)    # 0x7db730
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x246428
leaq 0x2aa40e(%rip), %rax    # 0x4f0834
jmp 0x246457
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x24643c
leaq 0x1b65dd(%rip), %rax    # 0x3fca17
jmp 0x246457
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x246450
leaq 0x54d32(%rip), %rax     # 0x29b180
jmp 0x246457
leaq 0xae87c(%rip), %rax     # 0x2f4cd3
movq %rax, 0x5952da(%rip)    # 0x7db738
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2464b1
leaq 0x28facb(%rip), %rax    # 0x4d5f7a
jmp 0x2464e0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2464c5
leaq 0x19f0f6(%rip), %rax    # 0x3e55b9
jmp 0x2464e0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2464d9
leaq 0x54ca9(%rip), %rax     # 0x29b180
jmp 0x2464e0
leaq 0x930e7(%rip), %rax     # 0x2d95c7
movq %rax, 0x595259(%rip)    # 0x7db740
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x24653a
leaq 0x293043(%rip), %rax    # 0x4d957b
jmp 0x246569
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x24654e
leaq 0x1a21d2(%rip), %rax    # 0x3e871e
jmp 0x246569
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x246562
leaq 0x54c20(%rip), %rax     # 0x29b180
jmp 0x246569
leaq 0x96aee(%rip), %rax     # 0x2dd057
movq %rax, 0x5951d8(%rip)    # 0x7db748
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2465c3
leaq 0x296f8e(%rip), %rax    # 0x4dd54f
jmp 0x2465f2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2465d7
leaq 0x1a5854(%rip), %rax    # 0x3ebe29
jmp 0x2465f2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2465eb
leaq 0x54b97(%rip), %rax     # 0x29b180
jmp 0x2465f2
leaq 0x9a483(%rip), %rax     # 0x2e0a75
movq %rax, 0x595157(%rip)    # 0x7db750
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x24664c
leaq 0x29bd19(%rip), %rax    # 0x4e2363
jmp 0x24667b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x246660
leaq 0x1a9867(%rip), %rax    # 0x3efec5
jmp 0x24667b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x246674
leaq 0x54b0e(%rip), %rax     # 0x29b180
jmp 0x24667b
leaq 0x9f028(%rip), %rax     # 0x2e56a3
movq %rax, 0x5950d6(%rip)    # 0x7db758
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_de_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2466d5
leaq 0x2ad5e3(%rip), %rax    # 0x4f3cb6
jmp 0x246704
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2466e9
leaq 0x1b859b(%rip), %rax    # 0x3fec82
jmp 0x246704
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2466fd
leaq 0x55d81(%rip), %rax     # 0x29c47c
jmp 0x246704
leaq 0xb2108(%rip), %rax     # 0x2f880c
movq %rax, 0x595055(%rip)    # 0x7db760
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_de_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x24675e
leaq 0x2af21d(%rip), %rax    # 0x4f5979
jmp 0x24678d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x246772
leaq 0x1ba0a9(%rip), %rax    # 0x400819
jmp 0x24678d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x246786
leaq 0x55cf8(%rip), %rax     # 0x29c47c
jmp 0x24678d
leaq 0xb40db(%rip), %rax     # 0x2fa868
movq %rax, 0x594fd4(%rip)    # 0x7db768
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_de_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2467e7
leaq 0x2b1d73(%rip), %rax    # 0x4f8558
jmp 0x246816
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2467fb
leaq 0x1bc063(%rip), %rax    # 0x40285c
jmp 0x246816
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x24680f
leaq 0x55c6f(%rip), %rax     # 0x29c47c
jmp 0x246816
leaq 0xb64e4(%rip), %rax     # 0x2fccfa
movq %rax, 0x594f53(%rip)    # 0x7db770
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