LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x1d1676
leaq 0x3563eb(%rip), %rax    # 0x527a5f
jmp 0x1d16a5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d168a
leaq 0x24b247(%rip), %rax    # 0x41c8cf
jmp 0x1d16a5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d169e
leaq 0x6b215(%rip), %rax     # 0x23c8b1
jmp 0x1d16a5
leaq 0x15213b(%rip), %rax    # 0x3237e0
movq %rax, 0x56bc3c(%rip)    # 0x73d2e8
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_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x1d16ff
leaq 0x35b5c6(%rip), %rax    # 0x52ccc3
jmp 0x1d172e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1713
leaq 0x24f3a1(%rip), %rax    # 0x420ab2
jmp 0x1d172e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1727
leaq 0x6b18c(%rip), %rax     # 0x23c8b1
jmp 0x1d172e
leaq 0x1566f1(%rip), %rax    # 0x327e1f
movq %rax, 0x56bbbb(%rip)    # 0x73d2f0
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_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_rowcol_diag_8_pointer = parasail_sg_de_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_diag_8_pointer = parasail_sg_de_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_diag_8_pointer = parasail_sg_de_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_diag_8_pointer = parasail_sg_de_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_diag_8_pointer = parasail_sg_de_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x1d1788
leaq 0x3624af(%rip), %rax    # 0x533c35
jmp 0x1d17b7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d179c
leaq 0x2545b0(%rip), %rax    # 0x425d4a
jmp 0x1d17b7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d17b0
leaq 0x6b103(%rip), %rax     # 0x23c8b1
jmp 0x1d17b7
leaq 0x15c44c(%rip), %rax    # 0x32dc03
movq %rax, 0x56bb3a(%rip)    # 0x73d2f8
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_de_dispatch.c
// Function: parasail_sg_de_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_de_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_de_trace_scan_64_pointer = parasail_sg_de_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_64_pointer = parasail_sg_de_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_64_pointer = parasail_sg_de_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_64_pointer = parasail_sg_de_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_64_pointer = parasail_sg_de_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_trace_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x1d1811
leaq 0x375ba4(%rip), %rax    # 0x5473b3
jmp 0x1d1840
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1825
leaq 0x26677d(%rip), %rax    # 0x437fa0
jmp 0x1d1840
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1839
leaq 0x6c0e8(%rip), %rax     # 0x23d91f
jmp 0x1d1840
leaq 0x170d22(%rip), %rax    # 0x342562
movq %rax, 0x56bab9(%rip)    # 0x73d300
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_de_dispatch.c
// Function: parasail_sg_de_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_trace_scan_32_pointer = parasail_sg_de_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_32_pointer = parasail_sg_de_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_32_pointer = parasail_sg_de_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_32_pointer = parasail_sg_de_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_32_pointer = parasail_sg_de_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_trace_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x1d189a
leaq 0x377a6a(%rip), %rax    # 0x549302
jmp 0x1d18c9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d18ae
leaq 0x26860e(%rip), %rax    # 0x439eba
jmp 0x1d18c9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d18c2
leaq 0x6c05f(%rip), %rax     # 0x23d91f
jmp 0x1d18c9
leaq 0x173092(%rip), %rax    # 0x34495b
movq %rax, 0x56ba38(%rip)    # 0x73d308
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_de_dispatch.c
// Function: parasail_sg_de_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_de_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_scan_16_pointer = parasail_sg_de_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_16_pointer = parasail_sg_de_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_16_pointer = parasail_sg_de_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_16_pointer = parasail_sg_de_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_16_pointer = parasail_sg_de_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_trace_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_trace_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1923
leaq 0x3797f2(%rip), %rax    # 0x54b113
jmp 0x1d1952
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1937
leaq 0x26a428(%rip), %rax    # 0x43bd5d
jmp 0x1d1952
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d194b
leaq 0x6bfd6(%rip), %rax     # 0x23d91f
jmp 0x1d1952
leaq 0x175014(%rip), %rax    # 0x346966
movq %rax, 0x56b9b7(%rip)    # 0x73d310
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_de_dispatch.c
// Function: parasail_sg_de_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_de_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_scan_8_pointer = parasail_sg_de_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_8_pointer = parasail_sg_de_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_8_pointer = parasail_sg_de_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_8_pointer = parasail_sg_de_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_8_pointer = parasail_sg_de_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_trace_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_trace_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d19ac
leaq 0x37b556(%rip), %rax    # 0x54cf00
jmp 0x1d19db
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d19c0
leaq 0x26c23b(%rip), %rax    # 0x43dbf9
jmp 0x1d19db
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d19d4
leaq 0x6bf4d(%rip), %rax     # 0x23d91f
jmp 0x1d19db
leaq 0x177126(%rip), %rax    # 0x348b01
movq %rax, 0x56b936(%rip)    # 0x73d318
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_de_trace_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_striped_64_pointer = parasail_sg_de_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_64_pointer = parasail_sg_de_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_64_pointer = parasail_sg_de_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_64_pointer = parasail_sg_de_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_64_pointer = parasail_sg_de_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_trace_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1a35
leaq 0x38d80e(%rip), %rax    # 0x55f241
jmp 0x1d1a64
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1a49
leaq 0x279d8d(%rip), %rax    # 0x44b7d4
jmp 0x1d1a64
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1a5d
leaq 0x6ae56(%rip), %rax     # 0x23c8b1
jmp 0x1d1a64
leaq 0x186687(%rip), %rax    # 0x3580eb
movq %rax, 0x56b8b5(%rip)    # 0x73d320
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_de_trace_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_striped_32_pointer = parasail_sg_de_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_32_pointer = parasail_sg_de_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_32_pointer = parasail_sg_de_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_32_pointer = parasail_sg_de_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_32_pointer = parasail_sg_de_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_trace_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1abe
leaq 0x38ff5d(%rip), %rax    # 0x561a19
jmp 0x1d1aed
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1ad2
leaq 0x27c488(%rip), %rax    # 0x44df58
jmp 0x1d1aed
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1ae6
leaq 0x6adcd(%rip), %rax     # 0x23c8b1
jmp 0x1d1aed
leaq 0x18942a(%rip), %rax    # 0x35af17
movq %rax, 0x56b834(%rip)    # 0x73d328
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_de_trace_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_striped_16_pointer = parasail_sg_de_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_16_pointer = parasail_sg_de_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_16_pointer = parasail_sg_de_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_16_pointer = parasail_sg_de_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_16_pointer = parasail_sg_de_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_trace_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1b47
leaq 0x39243c(%rip), %rax    # 0x563f81
jmp 0x1d1b76
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1b5b
leaq 0x27e954(%rip), %rax    # 0x4504ad
jmp 0x1d1b76
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1b6f
leaq 0x6ad44(%rip), %rax     # 0x23c8b1
jmp 0x1d1b76
leaq 0x18ba9a(%rip), %rax    # 0x35d610
movq %rax, 0x56b7b3(%rip)    # 0x73d330
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_de_trace_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_striped_8_pointer = parasail_sg_de_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_8_pointer = parasail_sg_de_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_8_pointer = parasail_sg_de_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_8_pointer = parasail_sg_de_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_8_pointer = parasail_sg_de_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_trace_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1bd0
leaq 0x394907(%rip), %rax    # 0x5664d5
jmp 0x1d1bff
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1be4
leaq 0x280e57(%rip), %rax    # 0x452a39
jmp 0x1d1bff
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1bf8
leaq 0x6acbb(%rip), %rax     # 0x23c8b1
jmp 0x1d1bff
leaq 0x18e346(%rip), %rax    # 0x35ff45
movq %rax, 0x56b732(%rip)    # 0x73d338
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_de_dispatch.c
// Function: parasail_sg_de_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_de_trace_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_diag_64_pointer = parasail_sg_de_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_diag_64_pointer = parasail_sg_de_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_diag_64_pointer = parasail_sg_de_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_diag_64_pointer = parasail_sg_de_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_diag_64_pointer = parasail_sg_de_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_trace_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1c59
leaq 0x37d80f(%rip), %rax    # 0x54f466
jmp 0x1d1c88
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1c6d
leaq 0x26e297(%rip), %rax    # 0x43ff02
jmp 0x1d1c88
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1c81
leaq 0x6ac32(%rip), %rax     # 0x23c8b1
jmp 0x1d1c88
leaq 0x1797d6(%rip), %rax    # 0x34b45e
movq %rax, 0x56b6b1(%rip)    # 0x73d340
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_de_dispatch.c
// Function: parasail_sg_de_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_de_trace_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_diag_32_pointer = parasail_sg_de_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_diag_32_pointer = parasail_sg_de_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_diag_32_pointer = parasail_sg_de_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_diag_32_pointer = parasail_sg_de_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_diag_32_pointer = parasail_sg_de_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_trace_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1ce2
leaq 0x38019b(%rip), %rax    # 0x551e7b
jmp 0x1d1d11
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1cf6
leaq 0x270389(%rip), %rax    # 0x44207d
jmp 0x1d1d11
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1d0a
leaq 0x6aba9(%rip), %rax     # 0x23c8b1
jmp 0x1d1d11
leaq 0x17bcc8(%rip), %rax    # 0x34d9d9
movq %rax, 0x56b630(%rip)    # 0x73d348
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_de_dispatch.c
// Function: parasail_sg_de_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_de_trace_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_diag_16_pointer = parasail_sg_de_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_diag_16_pointer = parasail_sg_de_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_diag_16_pointer = parasail_sg_de_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_diag_16_pointer = parasail_sg_de_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_diag_16_pointer = parasail_sg_de_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_trace_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1d6b
leaq 0x383aa8(%rip), %rax    # 0x555811
jmp 0x1d1d9a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1d7f
leaq 0x272b98(%rip), %rax    # 0x444915
jmp 0x1d1d9a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1d93
leaq 0x6ab20(%rip), %rax     # 0x23c8b1
jmp 0x1d1d9a
leaq 0x17e637(%rip), %rax    # 0x3503d1
movq %rax, 0x56b5af(%rip)    # 0x73d350
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_de_dispatch.c
// Function: parasail_sg_de_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_de_trace_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_trace_diag_8_pointer = parasail_sg_de_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_diag_8_pointer = parasail_sg_de_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_diag_8_pointer = parasail_sg_de_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_diag_8_pointer = parasail_sg_de_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_diag_8_pointer = parasail_sg_de_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_trace_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_trace_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1df4
leaq 0x389326(%rip), %rax    # 0x55b118
jmp 0x1d1e23
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1e08
leaq 0x276506(%rip), %rax    # 0x44830c
jmp 0x1d1e23
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1e1c
leaq 0x6aa97(%rip), %rax     # 0x23c8b1
jmp 0x1d1e23
leaq 0x182496(%rip), %rax    # 0x3542b9
movq %rax, 0x56b52e(%rip)    # 0x73d358
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_de_dispatch.c
// Function: parasail_sg_de_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_de_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_scan_profile_64_pointer = parasail_sg_de_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_scan_profile_64_pointer = parasail_sg_de_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_scan_profile_64_pointer = parasail_sg_de_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_scan_profile_64_pointer = parasail_sg_de_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_scan_profile_64_pointer = parasail_sg_de_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1e76
leaq 0x2830ab(%rip), %rax    # 0x454f1f
jmp 0x1d1e9c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1e8a
leaq 0x1903ba(%rip), %rax    # 0x362242
jmp 0x1d1e9c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d1ebb
leaq 0x7f335(%rip), %rax     # 0x2511d1
movq %rax, 0x56b4bd(%rip)    # 0x73d360
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_de_dispatch.c
// Function: parasail_sg_de_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_de_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_scan_profile_32_pointer = parasail_sg_de_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_scan_profile_32_pointer = parasail_sg_de_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_scan_profile_32_pointer = parasail_sg_de_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_scan_profile_32_pointer = parasail_sg_de_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_scan_profile_32_pointer = parasail_sg_de_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1ef0
leaq 0x284ca6(%rip), %rax    # 0x456b94
jmp 0x1d1f16
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1f04
leaq 0x191ed5(%rip), %rax    # 0x363dd7
jmp 0x1d1f16
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d1f35
leaq 0x812ca(%rip), %rax     # 0x2531e0
movq %rax, 0x56b44b(%rip)    # 0x73d368
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_de_dispatch.c
// Function: parasail_sg_de_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_de_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_scan_profile_16_pointer = parasail_sg_de_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_scan_profile_16_pointer = parasail_sg_de_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_scan_profile_16_pointer = parasail_sg_de_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_scan_profile_16_pointer = parasail_sg_de_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_scan_profile_16_pointer = parasail_sg_de_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1f6a
leaq 0x2867a8(%rip), %rax    # 0x458710
jmp 0x1d1f90
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1f7e
leaq 0x1939e6(%rip), %rax    # 0x365962
jmp 0x1d1f90
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d1faf
leaq 0x82f4c(%rip), %rax     # 0x254edc
movq %rax, 0x56b3d9(%rip)    # 0x73d370
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_de_dispatch.c
// Function: parasail_sg_de_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_de_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_scan_profile_8_pointer = parasail_sg_de_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_scan_profile_8_pointer = parasail_sg_de_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_scan_profile_8_pointer = parasail_sg_de_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_scan_profile_8_pointer = parasail_sg_de_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_scan_profile_8_pointer = parasail_sg_de_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1fe4
leaq 0x28829b(%rip), %rax    # 0x45a27d
jmp 0x1d200a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1ff8
leaq 0x195500(%rip), %rax    # 0x3674f6
jmp 0x1d200a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d2029
leaq 0x84d63(%rip), %rax     # 0x256d6d
movq %rax, 0x56b367(%rip)    # 0x73d378
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_de_dispatch.c
// Function: parasail_sg_de_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_de_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_striped_profile_64_pointer = parasail_sg_de_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_striped_profile_64_pointer = parasail_sg_de_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_striped_profile_64_pointer = parasail_sg_de_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_striped_profile_64_pointer = parasail_sg_de_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_striped_profile_64_pointer = parasail_sg_de_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d205e
leaq 0x293e85(%rip), %rax    # 0x465ee1
jmp 0x1d2084
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d2072
leaq 0x19f133(%rip), %rax    # 0x3711a3
jmp 0x1d2084
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d20a3
leaq 0x9066d(%rip), %rax     # 0x2626f1
movq %rax, 0x56b2f5(%rip)    # 0x73d380
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_de_dispatch.c
// Function: parasail_sg_de_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_de_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_striped_profile_32_pointer = parasail_sg_de_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_striped_profile_32_pointer = parasail_sg_de_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_striped_profile_32_pointer = parasail_sg_de_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_striped_profile_32_pointer = parasail_sg_de_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_striped_profile_32_pointer = parasail_sg_de_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d20d8
leaq 0x295885(%rip), %rax    # 0x46795b
jmp 0x1d20fe
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d20ec
leaq 0x1a0aa8(%rip), %rax    # 0x372b92
jmp 0x1d20fe
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d211d
leaq 0x92449(%rip), %rax     # 0x264547
movq %rax, 0x56b283(%rip)    # 0x73d388
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_de_dispatch.c
// Function: parasail_sg_de_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_de_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_striped_profile_16_pointer = parasail_sg_de_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_striped_profile_16_pointer = parasail_sg_de_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_striped_profile_16_pointer = parasail_sg_de_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_striped_profile_16_pointer = parasail_sg_de_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_striped_profile_16_pointer = parasail_sg_de_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d2152
leaq 0x2971a1(%rip), %rax    # 0x4692f1
jmp 0x1d2178
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d2166
leaq 0x1a239b(%rip), %rax    # 0x3744ff
jmp 0x1d2178
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d2197
leaq 0x93e3a(%rip), %rax     # 0x265fb2
movq %rax, 0x56b211(%rip)    # 0x73d390
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