LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_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_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c31d8
leaq 0x370a0a(%rip), %rax    # 0x533be0
jmp 0x1c3207
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c31ec
leaq 0x262b0b(%rip), %rax    # 0x425cf5
jmp 0x1c3207
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3200
leaq 0x7965e(%rip), %rax     # 0x23c85c
jmp 0x1c3207
leaq 0x16a9a7(%rip), %rax    # 0x32dbae
movq %rax, 0x5793ca(%rip)    # 0x73c5d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c3261
leaq 0x3840ff(%rip), %rax    # 0x54735e
jmp 0x1c3290
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3275
leaq 0x274cd8(%rip), %rax    # 0x437f4b
jmp 0x1c3290
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3289
leaq 0x7a643(%rip), %rax     # 0x23d8ca
jmp 0x1c3290
leaq 0x17f27d(%rip), %rax    # 0x34250d
movq %rax, 0x579349(%rip)    # 0x73c5e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c32ea
leaq 0x385fc5(%rip), %rax    # 0x5492ad
jmp 0x1c3319
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c32fe
leaq 0x276b69(%rip), %rax    # 0x439e65
jmp 0x1c3319
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3312
leaq 0x7a5ba(%rip), %rax     # 0x23d8ca
jmp 0x1c3319
leaq 0x1815ed(%rip), %rax    # 0x344906
movq %rax, 0x5792c8(%rip)    # 0x73c5e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c3373
leaq 0x387d4d(%rip), %rax    # 0x54b0be
jmp 0x1c33a2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3387
leaq 0x278983(%rip), %rax    # 0x43bd08
jmp 0x1c33a2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c339b
leaq 0x7a531(%rip), %rax     # 0x23d8ca
jmp 0x1c33a2
leaq 0x18356f(%rip), %rax    # 0x346911
movq %rax, 0x579247(%rip)    # 0x73c5f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c33fc
leaq 0x389ab1(%rip), %rax    # 0x54ceab
jmp 0x1c342b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3410
leaq 0x27a796(%rip), %rax    # 0x43dba4
jmp 0x1c342b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3424
leaq 0x7a4a8(%rip), %rax     # 0x23d8ca
jmp 0x1c342b
leaq 0x185681(%rip), %rax    # 0x348aac
movq %rax, 0x5791c6(%rip)    # 0x73c5f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c3485
leaq 0x39bd69(%rip), %rax    # 0x55f1ec
jmp 0x1c34b4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3499
leaq 0x2882e8(%rip), %rax    # 0x44b77f
jmp 0x1c34b4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c34ad
leaq 0x793b1(%rip), %rax     # 0x23c85c
jmp 0x1c34b4
leaq 0x194be2(%rip), %rax    # 0x358096
movq %rax, 0x579145(%rip)    # 0x73c600
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c350e
leaq 0x39e4b8(%rip), %rax    # 0x5619c4
jmp 0x1c353d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3522
leaq 0x28a9e3(%rip), %rax    # 0x44df03
jmp 0x1c353d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3536
leaq 0x79328(%rip), %rax     # 0x23c85c
jmp 0x1c353d
leaq 0x197985(%rip), %rax    # 0x35aec2
movq %rax, 0x5790c4(%rip)    # 0x73c608
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c3597
leaq 0x3a0997(%rip), %rax    # 0x563f2c
jmp 0x1c35c6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c35ab
leaq 0x28ceaf(%rip), %rax    # 0x450458
jmp 0x1c35c6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c35bf
leaq 0x7929f(%rip), %rax     # 0x23c85c
jmp 0x1c35c6
leaq 0x199ff5(%rip), %rax    # 0x35d5bb
movq %rax, 0x579043(%rip)    # 0x73c610
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c3620
leaq 0x3a2e62(%rip), %rax    # 0x566480
jmp 0x1c364f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3634
leaq 0x28f3b2(%rip), %rax    # 0x4529e4
jmp 0x1c364f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3648
leaq 0x79216(%rip), %rax     # 0x23c85c
jmp 0x1c364f
leaq 0x19c8a1(%rip), %rax    # 0x35fef0
movq %rax, 0x578fc2(%rip)    # 0x73c618
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c36a9
leaq 0x38bd6a(%rip), %rax    # 0x54f411
jmp 0x1c36d8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c36bd
leaq 0x27c7f2(%rip), %rax    # 0x43fead
jmp 0x1c36d8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c36d1
leaq 0x7918d(%rip), %rax     # 0x23c85c
jmp 0x1c36d8
leaq 0x187d31(%rip), %rax    # 0x34b409
movq %rax, 0x578f41(%rip)    # 0x73c620
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c3732
leaq 0x38e6f6(%rip), %rax    # 0x551e26
jmp 0x1c3761
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3746
leaq 0x27e8e4(%rip), %rax    # 0x442028
jmp 0x1c3761
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c375a
leaq 0x79104(%rip), %rax     # 0x23c85c
jmp 0x1c3761
leaq 0x18a223(%rip), %rax    # 0x34d984
movq %rax, 0x578ec0(%rip)    # 0x73c628
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c37bb
leaq 0x392003(%rip), %rax    # 0x5557bc
jmp 0x1c37ea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c37cf
leaq 0x2810f3(%rip), %rax    # 0x4448c0
jmp 0x1c37ea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c37e3
leaq 0x7907b(%rip), %rax     # 0x23c85c
jmp 0x1c37ea
leaq 0x18cb92(%rip), %rax    # 0x35037c
movq %rax, 0x578e3f(%rip)    # 0x73c630
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c3844
leaq 0x397881(%rip), %rax    # 0x55b0c3
jmp 0x1c3873
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3858
leaq 0x284a61(%rip), %rax    # 0x4482b7
jmp 0x1c3873
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c386c
leaq 0x78ff2(%rip), %rax     # 0x23c85c
jmp 0x1c3873
leaq 0x1909f1(%rip), %rax    # 0x354264
movq %rax, 0x578dbe(%rip)    # 0x73c638
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_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 0x5672cf
testl %eax, %eax
je 0x1c38c6
leaq 0x2915fd(%rip), %rax    # 0x454ec1
jmp 0x1c38ec
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c38da
leaq 0x19e90c(%rip), %rax    # 0x3621e4
jmp 0x1c38ec
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c390b
leaq 0x8d887(%rip), %rax     # 0x251173
movq %rax, 0x578d4d(%rip)    # 0x73c640
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c3940
leaq 0x2931f8(%rip), %rax    # 0x456b36
jmp 0x1c3966
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3954
leaq 0x1a0427(%rip), %rax    # 0x363d79
jmp 0x1c3966
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c3985
leaq 0x8f81c(%rip), %rax     # 0x253182
movq %rax, 0x578cdb(%rip)    # 0x73c648
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c39ba
leaq 0x294cfa(%rip), %rax    # 0x4586b2
jmp 0x1c39e0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c39ce
leaq 0x1a1f38(%rip), %rax    # 0x365904
jmp 0x1c39e0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c39ff
leaq 0x9149e(%rip), %rax     # 0x254e7e
movq %rax, 0x578c69(%rip)    # 0x73c650
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c3a34
leaq 0x2967ed(%rip), %rax    # 0x45a21f
jmp 0x1c3a5a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3a48
leaq 0x1a3a52(%rip), %rax    # 0x367498
jmp 0x1c3a5a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c3a79
leaq 0x932b5(%rip), %rax     # 0x256d0f
movq %rax, 0x578bf7(%rip)    # 0x73c658
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c3aae
leaq 0x2a23d7(%rip), %rax    # 0x465e83
jmp 0x1c3ad4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3ac2
leaq 0x1ad685(%rip), %rax    # 0x371145
jmp 0x1c3ad4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c3af3
leaq 0x9ebbf(%rip), %rax     # 0x262693
movq %rax, 0x578b85(%rip)    # 0x73c660
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c3b28
leaq 0x2a3dd7(%rip), %rax    # 0x4678fd
jmp 0x1c3b4e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3b3c
leaq 0x1aeffa(%rip), %rax    # 0x372b34
jmp 0x1c3b4e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c3b6d
leaq 0xa099b(%rip), %rax     # 0x2644e9
movq %rax, 0x578b13(%rip)    # 0x73c668
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c3ba2
leaq 0x2a56f3(%rip), %rax    # 0x469293
jmp 0x1c3bc8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3bb6
leaq 0x1b08ed(%rip), %rax    # 0x3744a1
jmp 0x1c3bc8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c3be7
leaq 0xa238c(%rip), %rax     # 0x265f54
movq %rax, 0x578aa1(%rip)    # 0x73c670
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c3c1c
leaq 0x2a7005(%rip), %rax    # 0x46ac1f
jmp 0x1c3c42
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3c30
leaq 0x1b21d0(%rip), %rax    # 0x375dfe
jmp 0x1c3c42
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c3c61
leaq 0xa3f76(%rip), %rax     # 0x267bb8
movq %rax, 0x578a2f(%rip)    # 0x73c678
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c3c96
leaq 0x2aa5ce(%rip), %rax    # 0x46e262
jmp 0x1c3cbc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3caa
leaq 0x1b5c05(%rip), %rax    # 0x3798ad
jmp 0x1c3cbc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1c3cdb
leaq 0xa7cae(%rip), %rax     # 0x26b96a
movq %rax, 0x5789bd(%rip)    # 0x73c680
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