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_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_trace_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_profile_8_pointer = parasail_sg_qe_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_trace_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2226a8
leaq 0x371d7d(%rip), %rax    # 0x594423
jmp 0x2226ce
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2226bc
leaq 0x261b71(%rip), %rax    # 0x48422b
jmp 0x2226ce
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2226ed
leaq 0x17e9ba(%rip), %rax    # 0x3a1088
movq %rax, 0x581123(%rip)    # 0x7a37f8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x222c15
leaq 0x263906(%rip), %rax    # 0x486519
jmp 0x222c44
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222c29
leaq 0x1800e7(%rip), %rax    # 0x3a2d0e
jmp 0x222c44
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222c3d
leaq 0x77d15(%rip), %rax     # 0x29a950
jmp 0x222c44
leaq 0x892bf(%rip), %rax     # 0x2abf03
movq %rax, 0x580bb5(%rip)    # 0x7a3800
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_qx_dispatch.c
// Function: parasail_sg_qx_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x222c9e
leaq 0x2653c3(%rip), %rax    # 0x48805f
jmp 0x222ccd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222cb2
leaq 0x181889(%rip), %rax    # 0x3a4539
jmp 0x222ccd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222cc6
leaq 0x77c8c(%rip), %rax     # 0x29a950
jmp 0x222ccd
leaq 0x8ac9e(%rip), %rax     # 0x2ad96b
movq %rax, 0x580b34(%rip)    # 0x7a3808
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_qx_dispatch.c
// Function: parasail_sg_qx_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x222d27
leaq 0x266a29(%rip), %rax    # 0x48974e
jmp 0x222d56
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222d3b
leaq 0x182ed3(%rip), %rax    # 0x3a5c0c
jmp 0x222d56
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222d4f
leaq 0x77c03(%rip), %rax     # 0x29a950
jmp 0x222d56
leaq 0x8c3ee(%rip), %rax     # 0x2af144
movq %rax, 0x580ab3(%rip)    # 0x7a3810
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_qx_dispatch.c
// Function: parasail_sg_qx_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x222db0
leaq 0x268066(%rip), %rax    # 0x48ae14
jmp 0x222ddf
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222dc4
leaq 0x18450c(%rip), %rax    # 0x3a72ce
jmp 0x222ddf
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222dd8
leaq 0x77b7a(%rip), %rax     # 0x29a950
jmp 0x222ddf
leaq 0x8dcf2(%rip), %rax     # 0x2b0ad1
movq %rax, 0x580a32(%rip)    # 0x7a3818
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x222e39
leaq 0x2746df(%rip), %rax    # 0x497516
jmp 0x222e68
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222e4d
leaq 0x18dac4(%rip), %rax    # 0x3b090f
jmp 0x222e68
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222e61
leaq 0x76c73(%rip), %rax     # 0x299ad2
jmp 0x222e68
leaq 0x98149(%rip), %rax     # 0x2bafb1
movq %rax, 0x5809b1(%rip)    # 0x7a3820
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x222ec2
leaq 0x275e17(%rip), %rax    # 0x498cd7
jmp 0x222ef1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222ed6
leaq 0x18f077(%rip), %rax    # 0x3b1f4b
jmp 0x222ef1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222eea
leaq 0x76bea(%rip), %rax     # 0x299ad2
jmp 0x222ef1
leaq 0x9988c(%rip), %rax     # 0x2bc77d
movq %rax, 0x580930(%rip)    # 0x7a3828
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x222f4b
leaq 0x27723c(%rip), %rax    # 0x49a185
jmp 0x222f7a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222f5f
leaq 0x190493(%rip), %rax    # 0x3b33f0
jmp 0x222f7a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222f73
leaq 0x76b61(%rip), %rax     # 0x299ad2
jmp 0x222f7a
leaq 0x9ad4e(%rip), %rax     # 0x2bdcc8
movq %rax, 0x5808af(%rip)    # 0x7a3830
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x222fd4
leaq 0x27868b(%rip), %rax    # 0x49b65d
jmp 0x223003
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x222fe8
leaq 0x1918df(%rip), %rax    # 0x3b48c5
jmp 0x223003
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x222ffc
leaq 0x76ad8(%rip), %rax     # 0x299ad2
jmp 0x223003
leaq 0x9c3f9(%rip), %rax     # 0x2bf3fc
movq %rax, 0x58082e(%rip)    # 0x7a3838
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_qx_dispatch.c
// Function: parasail_sg_qx_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x22305d
leaq 0x269e7a(%rip), %rax    # 0x48ced5
jmp 0x22308c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223071
leaq 0x185dc1(%rip), %rax    # 0x3a8e30
jmp 0x22308c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223085
leaq 0x76a4f(%rip), %rax     # 0x299ad2
jmp 0x22308c
leaq 0x8f952(%rip), %rax     # 0x2b29de
movq %rax, 0x5807ad(%rip)    # 0x7a3840
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_qx_dispatch.c
// Function: parasail_sg_qx_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x2230e6
leaq 0x26bdf8(%rip), %rax    # 0x48eedc
jmp 0x223115
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2230fa
leaq 0x18773c(%rip), %rax    # 0x3aa834
jmp 0x223115
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22310e
leaq 0x769c6(%rip), %rax     # 0x299ad2
jmp 0x223115
leaq 0x915e8(%rip), %rax     # 0x2b46fd
movq %rax, 0x58072c(%rip)    # 0x7a3848
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_qx_dispatch.c
// Function: parasail_sg_qx_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x22316f
leaq 0x26e239(%rip), %rax    # 0x4913a6
jmp 0x22319e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223183
leaq 0x1892fb(%rip), %rax    # 0x3ac47c
jmp 0x22319e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223197
leaq 0x7693d(%rip), %rax     # 0x299ad2
jmp 0x22319e
leaq 0x933be(%rip), %rax     # 0x2b655c
movq %rax, 0x5806ab(%rip)    # 0x7a3850
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_qx_dispatch.c
// Function: parasail_sg_qx_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x2231f8
leaq 0x271866(%rip), %rax    # 0x494a5c
jmp 0x223227
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22320c
leaq 0x18b71c(%rip), %rax    # 0x3ae926
jmp 0x223227
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223220
leaq 0x768b4(%rip), %rax     # 0x299ad2
jmp 0x223227
leaq 0x95bb7(%rip), %rax     # 0x2b8dde
movq %rax, 0x58062a(%rip)    # 0x7a3858
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223281
leaq 0x27b61a(%rip), %rax    # 0x49e899
jmp 0x2232b0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223295
leaq 0x1947b1(%rip), %rax    # 0x3b7a44
jmp 0x2232b0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2232a9
leaq 0x776a9(%rip), %rax     # 0x29a950
jmp 0x2232b0
leaq 0x9f0f6(%rip), %rax     # 0x2c23a6
movq %rax, 0x5805a9(%rip)    # 0x7a3860
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22330a
leaq 0x27e9f4(%rip), %rax    # 0x4a1cfc
jmp 0x223339
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22331e
leaq 0x1977dc(%rip), %rax    # 0x3baaf8
jmp 0x223339
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223332
leaq 0x77620(%rip), %rax     # 0x29a950
jmp 0x223339
leaq 0xa274a(%rip), %rax     # 0x2c5a83
movq %rax, 0x580528(%rip)    # 0x7a3868
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223393
leaq 0x281807(%rip), %rax    # 0x4a4b98
jmp 0x2233c2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2233a7
leaq 0x19a58e(%rip), %rax    # 0x3bd933
jmp 0x2233c2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2233bb
leaq 0x77597(%rip), %rax     # 0x29a950
jmp 0x2233c2
leaq 0xa5996(%rip), %rax     # 0x2c8d58
movq %rax, 0x5804a7(%rip)    # 0x7a3870
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22341c
leaq 0x284640(%rip), %rax    # 0x4a7a5a
jmp 0x22344b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223430
leaq 0x19d3e3(%rip), %rax    # 0x3c0811
jmp 0x22344b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223444
leaq 0x7750e(%rip), %rax     # 0x29a950
jmp 0x22344b
leaq 0xa8da6(%rip), %rax     # 0x2cc1f1
movq %rax, 0x580426(%rip)    # 0x7a3878
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2234a5
leaq 0x299042(%rip), %rax    # 0x4bc4e5
jmp 0x2234d4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2234b9
leaq 0x1aeaca(%rip), %rax    # 0x3d1f81
jmp 0x2234d4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2234cd
leaq 0x76607(%rip), %rax     # 0x299ad2
jmp 0x2234d4
leaq 0xbc58c(%rip), %rax     # 0x2dfa60
movq %rax, 0x5803a5(%rip)    # 0x7a3880
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22352e
leaq 0x29bfc7(%rip), %rax    # 0x4bf4f3
jmp 0x22355d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223542
leaq 0x1b184f(%rip), %rax    # 0x3d4d8f
jmp 0x22355d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223556
leaq 0x7657e(%rip), %rax     # 0x299ad2
jmp 0x22355d
leaq 0xbf973(%rip), %rax     # 0x2e2ed0
movq %rax, 0x580324(%rip)    # 0x7a3888
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2235b7
leaq 0x29eaee(%rip), %rax    # 0x4c20a3
jmp 0x2235e6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2235cb
leaq 0x1b43e2(%rip), %rax    # 0x3d79ab
jmp 0x2235e6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2235df
leaq 0x764f5(%rip), %rax     # 0x299ad2
jmp 0x2235e6
leaq 0xc28ba(%rip), %rax     # 0x2e5ea0
movq %rax, 0x5802a3(%rip)    # 0x7a3890
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223640
leaq 0x2a16ae(%rip), %rax    # 0x4c4cec
jmp 0x22366f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223654
leaq 0x1b7019(%rip), %rax    # 0x3da66b
jmp 0x22366f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223668
leaq 0x7646c(%rip), %rax     # 0x299ad2
jmp 0x22366f
leaq 0xc5a4e(%rip), %rax     # 0x2e90bd
movq %rax, 0x580222(%rip)    # 0x7a3898
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2236c9
leaq 0x287d98(%rip), %rax    # 0x4ab45f
jmp 0x2236f8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2236dd
leaq 0x1a058c(%rip), %rax    # 0x3c3c67
jmp 0x2236f8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2236f1
leaq 0x763e3(%rip), %rax     # 0x299ad2
jmp 0x2236f8
leaq 0xac6e9(%rip), %rax     # 0x2cfde1
movq %rax, 0x5801a1(%rip)    # 0x7a38a0
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223752
leaq 0x28b723(%rip), %rax    # 0x4aee73
jmp 0x223781
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223766
leaq 0x1a37d8(%rip), %rax    # 0x3c6f3c
jmp 0x223781
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22377a
leaq 0x7635a(%rip), %rax     # 0x299ad2
jmp 0x223781
leaq 0xb0031(%rip), %rax     # 0x2d37b2
movq %rax, 0x580120(%rip)    # 0x7a38a8
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