LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_trace_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x220696
leaq 0x3580a4(%rip), %rax    # 0x578738
jmp 0x2206c5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2206aa
leaq 0x24d589(%rip), %rax    # 0x46dc31
jmp 0x2206c5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2206be
leaq 0x7a279(%rip), %rax     # 0x29a935
jmp 0x2206c5
leaq 0x1682ad(%rip), %rax    # 0x388972
movq %rax, 0x582f1c(%rip)    # 0x7a35e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x22071f
leaq 0x359ada(%rip), %rax    # 0x57a1f7
jmp 0x22074e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220733
leaq 0x24ef29(%rip), %rax    # 0x46f65a
jmp 0x22074e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220747
leaq 0x7a1f0(%rip), %rax     # 0x29a935
jmp 0x22074e
leaq 0x169dd5(%rip), %rax    # 0x38a523
movq %rax, 0x582e9b(%rip)    # 0x7a35f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x2207a8
leaq 0x35b4f2(%rip), %rax    # 0x57bc98
jmp 0x2207d7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2207bc
leaq 0x2508f2(%rip), %rax    # 0x4710ac
jmp 0x2207d7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2207d0
leaq 0x7a167(%rip), %rax     # 0x29a935
jmp 0x2207d7
leaq 0x16ba5c(%rip), %rax    # 0x38c233
movq %rax, 0x582e1a(%rip)    # 0x7a35f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220831
leaq 0x36d1c9(%rip), %rax    # 0x58d9f8
jmp 0x220860
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220845
leaq 0x25d2b5(%rip), %rax    # 0x47daf8
jmp 0x220860
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220859
leaq 0x79260(%rip), %rax     # 0x299ab7
jmp 0x220860
leaq 0x1798d1(%rip), %rax    # 0x39a131
movq %rax, 0x582d99(%rip)    # 0x7a3600
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x2208ba
leaq 0x36f714(%rip), %rax    # 0x58ffcc
jmp 0x2208e9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2208ce
leaq 0x25f5e9(%rip), %rax    # 0x47feb5
jmp 0x2208e9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2208e2
leaq 0x791d7(%rip), %rax     # 0x299ab7
jmp 0x2208e9
leaq 0x17bfb1(%rip), %rax    # 0x39c89a
movq %rax, 0x582d18(%rip)    # 0x7a3608
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220943
leaq 0x3717f5(%rip), %rax    # 0x592136
jmp 0x220972
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220957
leaq 0x261667(%rip), %rax    # 0x481fbc
jmp 0x220972
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22096b
leaq 0x7914e(%rip), %rax     # 0x299ab7
jmp 0x220972
leaq 0x17e177(%rip), %rax    # 0x39eae9
movq %rax, 0x582c97(%rip)    # 0x7a3610
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x2209cc
leaq 0x373904(%rip), %rax    # 0x5942ce
jmp 0x2209fb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2209e0
leaq 0x2636f8(%rip), %rax    # 0x4840d6
jmp 0x2209fb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2209f4
leaq 0x790c5(%rip), %rax     # 0x299ab7
jmp 0x2209fb
leaq 0x180538(%rip), %rax    # 0x3a0f33
movq %rax, 0x582c16(%rip)    # 0x7a3618
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220a55
leaq 0x35d8ca(%rip), %rax    # 0x57e31d
jmp 0x220a84
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220a69
leaq 0x2525d7(%rip), %rax    # 0x47303e
jmp 0x220a84
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220a7d
leaq 0x7903c(%rip), %rax     # 0x299ab7
jmp 0x220a84
leaq 0x16dc44(%rip), %rax    # 0x38e6c8
movq %rax, 0x582b95(%rip)    # 0x7a3620
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220ade
leaq 0x36023e(%rip), %rax    # 0x580d1a
jmp 0x220b0d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220af2
leaq 0x254532(%rip), %rax    # 0x475022
jmp 0x220b0d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220b06
leaq 0x78fb3(%rip), %rax     # 0x299ab7
jmp 0x220b0d
leaq 0x16ff3e(%rip), %rax    # 0x390a4b
movq %rax, 0x582b14(%rip)    # 0x7a3628
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220b67
leaq 0x3637a5(%rip), %rax    # 0x58430a
jmp 0x220b96
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220b7b
leaq 0x2569ea(%rip), %rax    # 0x477563
jmp 0x220b96
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220b8f
leaq 0x78f2a(%rip), %rax     # 0x299ab7
jmp 0x220b96
leaq 0x172643(%rip), %rax    # 0x3931d9
movq %rax, 0x582a93(%rip)    # 0x7a3630
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_trace_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220bf0
leaq 0x368c22(%rip), %rax    # 0x589810
jmp 0x220c1f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220c04
leaq 0x259dbd(%rip), %rax    # 0x47a9bf
jmp 0x220c1f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220c18
leaq 0x78ea1(%rip), %rax     # 0x299ab7
jmp 0x220c1f
leaq 0x175f72(%rip), %rax    # 0x396b91
movq %rax, 0x582a12(%rip)    # 0x7a3638
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_64_pointer = parasail_sg_qe_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220c72
leaq 0x2659e3(%rip), %rax    # 0x486653
jmp 0x220c98
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220c86
leaq 0x1821c4(%rip), %rax    # 0x3a2e48
jmp 0x220c98
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x220cb7
leaq 0x8b3a5(%rip), %rax     # 0x2ac03d
movq %rax, 0x5829a1(%rip)    # 0x7a3640
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_32_pointer = parasail_sg_qe_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220cec
leaq 0x2674af(%rip), %rax    # 0x488199
jmp 0x220d12
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220d00
leaq 0x183975(%rip), %rax    # 0x3a4673
jmp 0x220d12
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x220d31
leaq 0x8cd93(%rip), %rax     # 0x2adaa5
movq %rax, 0x58292f(%rip)    # 0x7a3648
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_16_pointer = parasail_sg_qe_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220d66
leaq 0x268b24(%rip), %rax    # 0x489888
jmp 0x220d8c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220d7a
leaq 0x184fce(%rip), %rax    # 0x3a5d46
jmp 0x220d8c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x220dab
leaq 0x8e4f2(%rip), %rax     # 0x2af27e
movq %rax, 0x5828bd(%rip)    # 0x7a3650
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_profile_8_pointer = parasail_sg_qe_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220de0
leaq 0x26a170(%rip), %rax    # 0x48af4e
jmp 0x220e06
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220df4
leaq 0x186616(%rip), %rax    # 0x3a7408
jmp 0x220e06
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x220e25
leaq 0x8fe05(%rip), %rax     # 0x2b0c0b
movq %rax, 0x58284b(%rip)    # 0x7a3658
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_64_pointer = parasail_sg_qe_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220e5a
leaq 0x2767f8(%rip), %rax    # 0x497650
jmp 0x220e80
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220e6e
leaq 0x18fbdd(%rip), %rax    # 0x3b0a49
jmp 0x220e80
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x220e9f
leaq 0x9a26b(%rip), %rax     # 0x2bb0eb
movq %rax, 0x5827d9(%rip)    # 0x7a3660
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_profile_32_pointer = parasail_sg_qe_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_32_pointer = parasail_sg_qe_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220ed4
leaq 0x277f3f(%rip), %rax    # 0x498e11
jmp 0x220efa
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220ee8
leaq 0x19119f(%rip), %rax    # 0x3b2085
jmp 0x220efa
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x220f19
leaq 0x9b9bd(%rip), %rax     # 0x2bc8b7
movq %rax, 0x582767(%rip)    # 0x7a3668
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_profile_16_pointer = parasail_sg_qe_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_16_pointer = parasail_sg_qe_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220f4e
leaq 0x279373(%rip), %rax    # 0x49a2bf
jmp 0x220f74
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220f62
leaq 0x1925ca(%rip), %rax    # 0x3b352a
jmp 0x220f74
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x220f93
leaq 0x9ce8e(%rip), %rax     # 0x2bde02
movq %rax, 0x5826f5(%rip)    # 0x7a3670
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_qe_dispatch.c
// Function: parasail_sg_qe_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_profile_8_pointer = parasail_sg_qe_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_profile_8_pointer = parasail_sg_qe_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x220fc8
leaq 0x27a7d1(%rip), %rax    # 0x49b797
jmp 0x220fee
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220fdc
leaq 0x193a25(%rip), %rax    # 0x3b49ff
jmp 0x220fee
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22100d
leaq 0x9e548(%rip), %rax     # 0x2bf536
movq %rax, 0x582683(%rip)    # 0x7a3678
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_profile_64_pointer = parasail_sg_qe_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x221042
leaq 0x27d993(%rip), %rax    # 0x49e9d3
jmp 0x221068
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x221056
leaq 0x196b2a(%rip), %rax    # 0x3b7b7e
jmp 0x221068
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x221087
leaq 0xa1478(%rip), %rax     # 0x2c24e0
movq %rax, 0x582611(%rip)    # 0x7a3680
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_profile_32_pointer = parasail_sg_qe_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x2210bc
leaq 0x280d7c(%rip), %rax    # 0x4a1e36
jmp 0x2210e2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2210d0
leaq 0x199b64(%rip), %rax    # 0x3bac32
jmp 0x2210e2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x221101
leaq 0xa4adb(%rip), %rax     # 0x2c5bbd
movq %rax, 0x58259f(%rip)    # 0x7a3688
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_profile_16_pointer = parasail_sg_qe_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_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 0x221136
leaq 0x283b9e(%rip), %rax    # 0x4a4cd2
jmp 0x22115c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22114a
leaq 0x19c925(%rip), %rax    # 0x3bda6d
jmp 0x22115c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22117b
leaq 0xa7d36(%rip), %rax     # 0x2c8e92
movq %rax, 0x58252d(%rip)    # 0x7a3690
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