LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_trace_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 0x2385ef
leaq 0x341c9f(%rip), %rax    # 0x57a28c
jmp 0x23861e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238603
leaq 0x2370ee(%rip), %rax    # 0x46f6ef
jmp 0x23861e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x238617
leaq 0x623b5(%rip), %rax     # 0x29a9ca
jmp 0x23861e
leaq 0x151f9a(%rip), %rax    # 0x38a5b8
movq %rax, 0x56c5ab(%rip)    # 0x7a4bd0
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_trace_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 0x238678
leaq 0x3436b7(%rip), %rax    # 0x57bd2d
jmp 0x2386a7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23868c
leaq 0x238ab7(%rip), %rax    # 0x471141
jmp 0x2386a7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2386a0
leaq 0x6232c(%rip), %rax     # 0x29a9ca
jmp 0x2386a7
leaq 0x153c21(%rip), %rax    # 0x38c2c8
movq %rax, 0x56c52a(%rip)    # 0x7a4bd8
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x238701
leaq 0x35538e(%rip), %rax    # 0x58da8d
jmp 0x238730
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238715
leaq 0x24547a(%rip), %rax    # 0x47db8d
jmp 0x238730
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x238729
leaq 0x61425(%rip), %rax     # 0x299b4c
jmp 0x238730
leaq 0x161a96(%rip), %rax    # 0x39a1c6
movq %rax, 0x56c4a9(%rip)    # 0x7a4be0
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x23878a
leaq 0x3578d9(%rip), %rax    # 0x590061
jmp 0x2387b9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23879e
leaq 0x2477ae(%rip), %rax    # 0x47ff4a
jmp 0x2387b9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2387b2
leaq 0x6139c(%rip), %rax     # 0x299b4c
jmp 0x2387b9
leaq 0x164176(%rip), %rax    # 0x39c92f
movq %rax, 0x56c428(%rip)    # 0x7a4be8
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x238813
leaq 0x3599ba(%rip), %rax    # 0x5921cb
jmp 0x238842
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238827
leaq 0x24982c(%rip), %rax    # 0x482051
jmp 0x238842
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23883b
leaq 0x61313(%rip), %rax     # 0x299b4c
jmp 0x238842
leaq 0x16633c(%rip), %rax    # 0x39eb7e
movq %rax, 0x56c3a7(%rip)    # 0x7a4bf0
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x23889c
leaq 0x35bac9(%rip), %rax    # 0x594363
jmp 0x2388cb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2388b0
leaq 0x24b8bd(%rip), %rax    # 0x48416b
jmp 0x2388cb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2388c4
leaq 0x6128a(%rip), %rax     # 0x299b4c
jmp 0x2388cb
leaq 0x1686fd(%rip), %rax    # 0x3a0fc8
movq %rax, 0x56c326(%rip)    # 0x7a4bf8
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x238925
leaq 0x345a8f(%rip), %rax    # 0x57e3b2
jmp 0x238954
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238939
leaq 0x23a79c(%rip), %rax    # 0x4730d3
jmp 0x238954
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23894d
leaq 0x61201(%rip), %rax     # 0x299b4c
jmp 0x238954
leaq 0x155e09(%rip), %rax    # 0x38e75d
movq %rax, 0x56c2a5(%rip)    # 0x7a4c00
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x2389ae
leaq 0x348403(%rip), %rax    # 0x580daf
jmp 0x2389dd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2389c2
leaq 0x23c6f7(%rip), %rax    # 0x4750b7
jmp 0x2389dd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2389d6
leaq 0x61178(%rip), %rax     # 0x299b4c
jmp 0x2389dd
leaq 0x158103(%rip), %rax    # 0x390ae0
movq %rax, 0x56c224(%rip)    # 0x7a4c08
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x238a37
leaq 0x34b96a(%rip), %rax    # 0x58439f
jmp 0x238a66
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238a4b
leaq 0x23ebaf(%rip), %rax    # 0x4775f8
jmp 0x238a66
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x238a5f
leaq 0x610ef(%rip), %rax     # 0x299b4c
jmp 0x238a66
leaq 0x15a808(%rip), %rax    # 0x39326e
movq %rax, 0x56c1a3(%rip)    # 0x7a4c10
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_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_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x238ac0
leaq 0x350de7(%rip), %rax    # 0x5898a5
jmp 0x238aef
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238ad4
leaq 0x241f82(%rip), %rax    # 0x47aa54
jmp 0x238aef
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x238ae8
leaq 0x61066(%rip), %rax     # 0x299b4c
jmp 0x238aef
leaq 0x15e137(%rip), %rax    # 0x396c26
movq %rax, 0x56c122(%rip)    # 0x7a4c18
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_profile_64_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_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_profile_64_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 0x238b42
leaq 0x24db96(%rip), %rax    # 0x4866d6
jmp 0x238b68
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238b56
leaq 0x16a377(%rip), %rax    # 0x3a2ecb
jmp 0x238b68
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238b87
leaq 0x73558(%rip), %rax     # 0x2ac0c0
movq %rax, 0x56c0b1(%rip)    # 0x7a4c20
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_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_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_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 0x594f9c
testl %eax, %eax
je 0x238bbc
leaq 0x24f662(%rip), %rax    # 0x48821c
jmp 0x238be2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238bd0
leaq 0x16bb28(%rip), %rax    # 0x3a46f6
jmp 0x238be2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238c01
leaq 0x74f46(%rip), %rax     # 0x2adb28
movq %rax, 0x56c03f(%rip)    # 0x7a4c28
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_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_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_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 0x594f9c
testl %eax, %eax
je 0x238c36
leaq 0x250cd7(%rip), %rax    # 0x48990b
jmp 0x238c5c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238c4a
leaq 0x16d181(%rip), %rax    # 0x3a5dc9
jmp 0x238c5c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238c7b
leaq 0x766a5(%rip), %rax     # 0x2af301
movq %rax, 0x56bfcd(%rip)    # 0x7a4c30
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_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_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_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 0x238cb0
leaq 0x252323(%rip), %rax    # 0x48afd1
jmp 0x238cd6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238cc4
leaq 0x16e7c9(%rip), %rax    # 0x3a748b
jmp 0x238cd6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238cf5
leaq 0x77fb8(%rip), %rax     # 0x2b0c8e
movq %rax, 0x56bf5b(%rip)    # 0x7a4c38
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_de_striped_profile_64_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_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_striped_profile_64_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 0x238d2a
leaq 0x25e9ab(%rip), %rax    # 0x4976d3
jmp 0x238d50
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238d3e
leaq 0x177d90(%rip), %rax    # 0x3b0acc
jmp 0x238d50
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238d6f
leaq 0x8241e(%rip), %rax     # 0x2bb16e
movq %rax, 0x56bee9(%rip)    # 0x7a4c40
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x238da4
leaq 0x2600f2(%rip), %rax    # 0x498e94
jmp 0x238dca
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238db8
leaq 0x179352(%rip), %rax    # 0x3b2108
jmp 0x238dca
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238de9
leaq 0x83b70(%rip), %rax     # 0x2bc93a
movq %rax, 0x56be77(%rip)    # 0x7a4c48
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x238e1e
leaq 0x261526(%rip), %rax    # 0x49a342
jmp 0x238e44
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238e32
leaq 0x17a77d(%rip), %rax    # 0x3b35ad
jmp 0x238e44
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238e63
leaq 0x85041(%rip), %rax     # 0x2bde85
movq %rax, 0x56be05(%rip)    # 0x7a4c50
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_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 0x238e98
leaq 0x262984(%rip), %rax    # 0x49b81a
jmp 0x238ebe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238eac
leaq 0x17bbd8(%rip), %rax    # 0x3b4a82
jmp 0x238ebe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238edd
leaq 0x866fb(%rip), %rax     # 0x2bf5b9
movq %rax, 0x56bd93(%rip)    # 0x7a4c58
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_profile_64_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_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_stats_scan_profile_64_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 0x238f12
leaq 0x265b46(%rip), %rax    # 0x49ea56
jmp 0x238f38
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238f26
leaq 0x17ecdd(%rip), %rax    # 0x3b7c01
jmp 0x238f38
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238f57
leaq 0x8962b(%rip), %rax     # 0x2c2563
movq %rax, 0x56bd21(%rip)    # 0x7a4c60
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_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_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_stats_scan_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 0x594f9c
testl %eax, %eax
je 0x238f8c
leaq 0x268f2f(%rip), %rax    # 0x4a1eb9
jmp 0x238fb2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x238fa0
leaq 0x181d17(%rip), %rax    # 0x3bacb5
jmp 0x238fb2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x238fd1
leaq 0x8cc8e(%rip), %rax     # 0x2c5c40
movq %rax, 0x56bcaf(%rip)    # 0x7a4c68
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_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_qb_de_stats_scan_profile_16_pointer = parasail_sg_qb_de_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_profile_16_pointer = parasail_sg_qb_de_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_profile_16_pointer = parasail_sg_qb_de_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_profile_16_pointer = parasail_sg_qb_de_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_profile_16_pointer = parasail_sg_qb_de_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_stats_scan_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 0x594f9c
testl %eax, %eax
je 0x239006
leaq 0x26bd51(%rip), %rax    # 0x4a4d55
jmp 0x23902c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23901a
leaq 0x184ad8(%rip), %rax    # 0x3bdaf0
jmp 0x23902c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x23904b
leaq 0x8fee9(%rip), %rax     # 0x2c8f15
movq %rax, 0x56bc3d(%rip)    # 0x7a4c70
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_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_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_qb_de_stats_scan_profile_8_pointer = parasail_sg_qb_de_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_profile_8_pointer = parasail_sg_qb_de_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_profile_8_pointer = parasail_sg_qb_de_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_profile_8_pointer = parasail_sg_qb_de_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_profile_8_pointer = parasail_sg_qb_de_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_stats_scan_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 0x239080
leaq 0x26eb99(%rip), %rax    # 0x4a7c17
jmp 0x2390a6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x239094
leaq 0x18793c(%rip), %rax    # 0x3c09ce
jmp 0x2390a6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2390c5
leaq 0x93308(%rip), %rax     # 0x2cc3ae
movq %rax, 0x56bbcb(%rip)    # 0x7a4c78
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