LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_trace_striped_profile_32_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_32_pointer = parasail_sg_qe_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_profile_32_pointer = parasail_sg_qe_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_profile_32_pointer = parasail_sg_qe_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_profile_32_pointer = parasail_sg_qe_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_profile_32_pointer = parasail_sg_qe_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_trace_striped_profile_32_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 0x5672cf
testl %eax, %eax
je 0x1c5208
leaq 0x39c8f5(%rip), %rax    # 0x561afb
jmp 0x1c522e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c521c
leaq 0x288e20(%rip), %rax    # 0x44e03a
jmp 0x1c522e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c524d
leaq 0x195dcb(%rip), %rax    # 0x35aff9
movq %rax, 0x5775b3(%rip)    # 0x73c7e8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_trace_striped_profile_16_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_16_pointer = parasail_sg_qe_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_profile_16_pointer = parasail_sg_qe_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_profile_16_pointer = parasail_sg_qe_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_profile_16_pointer = parasail_sg_qe_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_profile_16_pointer = parasail_sg_qe_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_trace_striped_profile_16_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 0x5672cf
testl %eax, %eax
je 0x1c5282
leaq 0x39ede3(%rip), %rax    # 0x564063
jmp 0x1c52a8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5296
leaq 0x28b2fb(%rip), %rax    # 0x45058f
jmp 0x1c52a8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c52c7
leaq 0x19844a(%rip), %rax    # 0x35d6f2
movq %rax, 0x577541(%rip)    # 0x73c7f0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c52fc
leaq 0x3a12bd(%rip), %rax    # 0x5665b7
jmp 0x1c5322
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5310
leaq 0x28d80d(%rip), %rax    # 0x452b1b
jmp 0x1c5322
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c5341
leaq 0x19ad05(%rip), %rax    # 0x360027
movq %rax, 0x5774cf(%rip)    # 0x73c7f8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1c5869
leaq 0x28f53f(%rip), %rax    # 0x454da6
jmp 0x1c5898
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c587d
leaq 0x19c84e(%rip), %rax    # 0x3620c9
jmp 0x1c5898
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5891
leaq 0x78057(%rip), %rax     # 0x23d8e6
jmp 0x1c5898
leaq 0x8b7c0(%rip), %rax     # 0x251058
movq %rax, 0x576f61(%rip)    # 0x73c800
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c58f2
leaq 0x29112b(%rip), %rax    # 0x456a1b
jmp 0x1c5921
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5906
leaq 0x19e35a(%rip), %rax    # 0x363c5e
jmp 0x1c5921
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c591a
leaq 0x77fce(%rip), %rax     # 0x23d8e6
jmp 0x1c5921
leaq 0x8d746(%rip), %rax     # 0x253067
movq %rax, 0x576ee0(%rip)    # 0x73c808
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c597b
leaq 0x292c1e(%rip), %rax    # 0x458597
jmp 0x1c59aa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c598f
leaq 0x19fe5c(%rip), %rax    # 0x3657e9
jmp 0x1c59aa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c59a3
leaq 0x77f45(%rip), %rax     # 0x23d8e6
jmp 0x1c59aa
leaq 0x8f3b9(%rip), %rax     # 0x254d63
movq %rax, 0x576e5f(%rip)    # 0x73c810
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5a04
leaq 0x294702(%rip), %rax    # 0x45a104
jmp 0x1c5a33
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5a18
leaq 0x1a1967(%rip), %rax    # 0x36737d
jmp 0x1c5a33
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5a2c
leaq 0x77ebc(%rip), %rax     # 0x23d8e6
jmp 0x1c5a33
leaq 0x911c1(%rip), %rax     # 0x256bf4
movq %rax, 0x576dde(%rip)    # 0x73c818
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5a8d
leaq 0x2a02dd(%rip), %rax    # 0x465d68
jmp 0x1c5abc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5aa1
leaq 0x1ab58b(%rip), %rax    # 0x37102a
jmp 0x1c5abc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5ab5
leaq 0x76dc5(%rip), %rax     # 0x23c878
jmp 0x1c5abc
leaq 0x9cabc(%rip), %rax     # 0x262578
movq %rax, 0x576d5d(%rip)    # 0x73c820
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5b16
leaq 0x2a1cce(%rip), %rax    # 0x4677e2
jmp 0x1c5b45
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5b2a
leaq 0x1acef1(%rip), %rax    # 0x372a19
jmp 0x1c5b45
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5b3e
leaq 0x76d3c(%rip), %rax     # 0x23c878
jmp 0x1c5b45
leaq 0x9e889(%rip), %rax     # 0x2643ce
movq %rax, 0x576cdc(%rip)    # 0x73c828
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5b9f
leaq 0x2a35db(%rip), %rax    # 0x469178
jmp 0x1c5bce
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5bb3
leaq 0x1ae7d5(%rip), %rax    # 0x374386
jmp 0x1c5bce
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5bc7
leaq 0x76cb3(%rip), %rax     # 0x23c878
jmp 0x1c5bce
leaq 0xa026b(%rip), %rax     # 0x265e39
movq %rax, 0x576c5b(%rip)    # 0x73c830
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5c28
leaq 0x2a4ede(%rip), %rax    # 0x46ab04
jmp 0x1c5c57
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5c3c
leaq 0x1b00a9(%rip), %rax    # 0x375ce3
jmp 0x1c5c57
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5c50
leaq 0x76c2a(%rip), %rax     # 0x23c878
jmp 0x1c5c57
leaq 0xa1e46(%rip), %rax     # 0x267a9d
movq %rax, 0x576bda(%rip)    # 0x73c838
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5cb1
leaq 0x2964cf(%rip), %rax    # 0x45c17e
jmp 0x1c5ce0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5cc5
leaq 0x1a345f(%rip), %rax    # 0x369122
jmp 0x1c5ce0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5cd9
leaq 0x76ba1(%rip), %rax     # 0x23c878
jmp 0x1c5ce0
leaq 0x9336a(%rip), %rax     # 0x25904a
movq %rax, 0x576b59(%rip)    # 0x73c840
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5d3a
leaq 0x2983d8(%rip), %rax    # 0x45e110
jmp 0x1c5d69
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5d4e
leaq 0x1a4f3f(%rip), %rax    # 0x36ac8b
jmp 0x1c5d69
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5d62
leaq 0x76b18(%rip), %rax     # 0x23c878
jmp 0x1c5d69
leaq 0x952a4(%rip), %rax     # 0x25b00d
movq %rax, 0x576ad8(%rip)    # 0x73c848
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5dc3
leaq 0x29a8b8(%rip), %rax    # 0x460679
jmp 0x1c5df2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5dd7
leaq 0x1a6b9d(%rip), %rax    # 0x36c972
jmp 0x1c5df2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5deb
leaq 0x76a8f(%rip), %rax     # 0x23c878
jmp 0x1c5df2
leaq 0x97224(%rip), %rax     # 0x25d016
movq %rax, 0x576a57(%rip)    # 0x73c850
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5e4c
leaq 0x29d8c5(%rip), %rax    # 0x46370f
jmp 0x1c5e7b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5e60
leaq 0x1a8f7e(%rip), %rax    # 0x36eddc
jmp 0x1c5e7b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5e74
leaq 0x76a06(%rip), %rax     # 0x23c878
jmp 0x1c5e7b
leaq 0x99dd0(%rip), %rax     # 0x25fc4b
movq %rax, 0x5769d6(%rip)    # 0x73c858
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5ed5
leaq 0x2a8274(%rip), %rax    # 0x46e147
jmp 0x1c5f04
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5ee9
leaq 0x1b38ab(%rip), %rax    # 0x379792
jmp 0x1c5f04
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5efd
leaq 0x779eb(%rip), %rax     # 0x23d8e6
jmp 0x1c5f04
leaq 0xa594b(%rip), %rax     # 0x26b84f
movq %rax, 0x576955(%rip)    # 0x73c860
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5f5e
leaq 0x2ab994(%rip), %rax    # 0x4718f0
jmp 0x1c5f8d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5f72
leaq 0x1b6ecd(%rip), %rax    # 0x37ce3d
jmp 0x1c5f8d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c5f86
leaq 0x77962(%rip), %rax     # 0x23d8e6
jmp 0x1c5f8d
leaq 0xa98a3(%rip), %rax     # 0x26f830
movq %rax, 0x5768d4(%rip)    # 0x73c868
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c5fe7
leaq 0x2aec3c(%rip), %rax    # 0x474c21
jmp 0x1c6016
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c5ffb
leaq 0x1ba18f(%rip), %rax    # 0x380188
jmp 0x1c6016
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c600f
leaq 0x778d9(%rip), %rax     # 0x23d8e6
jmp 0x1c6016
leaq 0xacfeb(%rip), %rax     # 0x273001
movq %rax, 0x576853(%rip)    # 0x73c870
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c6070
leaq 0x2b1ee7(%rip), %rax    # 0x477f55
jmp 0x1c609f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6084
leaq 0x1bd4b5(%rip), %rax    # 0x383537
jmp 0x1c609f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6098
leaq 0x77850(%rip), %rax     # 0x23d8e6
jmp 0x1c609f
leaq 0xb08c1(%rip), %rax     # 0x276960
movq %rax, 0x5767d2(%rip)    # 0x73c878
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c60f9
leaq 0x2c5ea3(%rip), %rax    # 0x48bf9a
jmp 0x1c6128
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c610d
leaq 0x1cf691(%rip), %rax    # 0x39579c
jmp 0x1c6128
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6121
leaq 0x76759(%rip), %rax     # 0x23c878
jmp 0x1c6128
leaq 0xc5a3a(%rip), %rax     # 0x28bb62
movq %rax, 0x576751(%rip)    # 0x73c880
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c6182
leaq 0x2c9236(%rip), %rax    # 0x48f3b6
jmp 0x1c61b1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c6196
leaq 0x1d2aeb(%rip), %rax    # 0x398c7f
jmp 0x1c61b1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c61aa
leaq 0x766d0(%rip), %rax     # 0x23c878
jmp 0x1c61b1
leaq 0xc96f3(%rip), %rax     # 0x28f8a4
movq %rax, 0x5766d0(%rip)    # 0x73c888
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c620b
leaq 0x2cc2e8(%rip), %rax    # 0x4924f1
jmp 0x1c623a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c621f
leaq 0x1d5cee(%rip), %rax    # 0x39bf0b
jmp 0x1c623a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c6233
leaq 0x76647(%rip), %rax     # 0x23c878
jmp 0x1c623a
leaq 0xccc66(%rip), %rax     # 0x292ea0
movq %rax, 0x57664f(%rip)    # 0x73c890
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