LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x22eb34
leaq 0x3343bf(%rip), %rax    # 0x562ef1
jmp 0x22eb63
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22eb48
leaq 0x22c0d3(%rip), %rax    # 0x45ac19
jmp 0x22eb63
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22eb5c
leaq 0x6afb5(%rip), %rax     # 0x299b0f
jmp 0x22eb63
leaq 0x14514c(%rip), %rax    # 0x373caf
movq %rax, 0x57578e(%rip)    # 0x7a42f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22ebbd
leaq 0x347c4e(%rip), %rax    # 0x576809
jmp 0x22ebec
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ebd1
leaq 0x23d4ee(%rip), %rax    # 0x46c0bd
jmp 0x22ebec
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ebe5
leaq 0x6bdaa(%rip), %rax     # 0x29a98d
jmp 0x22ebec
leaq 0x157f34(%rip), %rax    # 0x386b20
movq %rax, 0x57570d(%rip)    # 0x7a4300
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22ec46
leaq 0x349b4c(%rip), %rax    # 0x578790
jmp 0x22ec75
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ec5a
leaq 0x23f031(%rip), %rax    # 0x46dc89
jmp 0x22ec75
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ec6e
leaq 0x6bd21(%rip), %rax     # 0x29a98d
jmp 0x22ec75
leaq 0x159d55(%rip), %rax    # 0x3889ca
movq %rax, 0x57568c(%rip)    # 0x7a4308
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22eccf
leaq 0x34b582(%rip), %rax    # 0x57a24f
jmp 0x22ecfe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ece3
leaq 0x2409d1(%rip), %rax    # 0x46f6b2
jmp 0x22ecfe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ecf7
leaq 0x6bc98(%rip), %rax     # 0x29a98d
jmp 0x22ecfe
leaq 0x15b87d(%rip), %rax    # 0x38a57b
movq %rax, 0x57560b(%rip)    # 0x7a4310
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22ed58
leaq 0x34cf9a(%rip), %rax    # 0x57bcf0
jmp 0x22ed87
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ed6c
leaq 0x24239a(%rip), %rax    # 0x471104
jmp 0x22ed87
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ed80
leaq 0x6bc0f(%rip), %rax     # 0x29a98d
jmp 0x22ed87
leaq 0x15d504(%rip), %rax    # 0x38c28b
movq %rax, 0x57558a(%rip)    # 0x7a4318
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22ede1
leaq 0x35ec71(%rip), %rax    # 0x58da50
jmp 0x22ee10
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22edf5
leaq 0x24ed5d(%rip), %rax    # 0x47db50
jmp 0x22ee10
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ee09
leaq 0x6ad08(%rip), %rax     # 0x299b0f
jmp 0x22ee10
leaq 0x16b379(%rip), %rax    # 0x39a189
movq %rax, 0x575509(%rip)    # 0x7a4320
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22ee6a
leaq 0x3611bc(%rip), %rax    # 0x590024
jmp 0x22ee99
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ee7e
leaq 0x251091(%rip), %rax    # 0x47ff0d
jmp 0x22ee99
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ee92
leaq 0x6ac7f(%rip), %rax     # 0x299b0f
jmp 0x22ee99
leaq 0x16da59(%rip), %rax    # 0x39c8f2
movq %rax, 0x575488(%rip)    # 0x7a4328
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22eef3
leaq 0x36329d(%rip), %rax    # 0x59218e
jmp 0x22ef22
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ef07
leaq 0x25310f(%rip), %rax    # 0x482014
jmp 0x22ef22
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ef1b
leaq 0x6abf6(%rip), %rax     # 0x299b0f
jmp 0x22ef22
leaq 0x16fc1f(%rip), %rax    # 0x39eb41
movq %rax, 0x575407(%rip)    # 0x7a4330
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22ef7c
leaq 0x3653ac(%rip), %rax    # 0x594326
jmp 0x22efab
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ef90
leaq 0x2551a0(%rip), %rax    # 0x48412e
jmp 0x22efab
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22efa4
leaq 0x6ab6d(%rip), %rax     # 0x299b0f
jmp 0x22efab
leaq 0x171fe0(%rip), %rax    # 0x3a0f8b
movq %rax, 0x575386(%rip)    # 0x7a4338
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f005
leaq 0x34f372(%rip), %rax    # 0x57e375
jmp 0x22f034
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f019
leaq 0x24407f(%rip), %rax    # 0x473096
jmp 0x22f034
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22f02d
leaq 0x6aae4(%rip), %rax     # 0x299b0f
jmp 0x22f034
leaq 0x15f6ec(%rip), %rax    # 0x38e720
movq %rax, 0x575305(%rip)    # 0x7a4340
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f08e
leaq 0x351ce6(%rip), %rax    # 0x580d72
jmp 0x22f0bd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f0a2
leaq 0x245fda(%rip), %rax    # 0x47507a
jmp 0x22f0bd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22f0b6
leaq 0x6aa5b(%rip), %rax     # 0x299b0f
jmp 0x22f0bd
leaq 0x1619e6(%rip), %rax    # 0x390aa3
movq %rax, 0x575284(%rip)    # 0x7a4348
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f117
leaq 0x35524d(%rip), %rax    # 0x584362
jmp 0x22f146
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f12b
leaq 0x248492(%rip), %rax    # 0x4775bb
jmp 0x22f146
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22f13f
leaq 0x6a9d2(%rip), %rax     # 0x299b0f
jmp 0x22f146
leaq 0x1640eb(%rip), %rax    # 0x393231
movq %rax, 0x575203(%rip)    # 0x7a4350
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f1a0
leaq 0x35a6ca(%rip), %rax    # 0x589868
jmp 0x22f1cf
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f1b4
leaq 0x24b865(%rip), %rax    # 0x47aa17
jmp 0x22f1cf
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22f1c8
leaq 0x6a949(%rip), %rax     # 0x299b0f
jmp 0x22f1cf
leaq 0x167a1a(%rip), %rax    # 0x396be9
movq %rax, 0x575182(%rip)    # 0x7a4358
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f222
leaq 0x257481(%rip), %rax    # 0x4866a1
jmp 0x22f248
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f236
leaq 0x173c62(%rip), %rax    # 0x3a2e96
jmp 0x22f248
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f267
leaq 0x7ce43(%rip), %rax     # 0x2ac08b
movq %rax, 0x575111(%rip)    # 0x7a4360
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f29c
leaq 0x258f4d(%rip), %rax    # 0x4881e7
jmp 0x22f2c2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f2b0
leaq 0x175413(%rip), %rax    # 0x3a46c1
jmp 0x22f2c2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f2e1
leaq 0x7e831(%rip), %rax     # 0x2adaf3
movq %rax, 0x57509f(%rip)    # 0x7a4368
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f316
leaq 0x25a5c2(%rip), %rax    # 0x4898d6
jmp 0x22f33c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f32a
leaq 0x176a6c(%rip), %rax    # 0x3a5d94
jmp 0x22f33c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f35b
leaq 0x7ff90(%rip), %rax     # 0x2af2cc
movq %rax, 0x57502d(%rip)    # 0x7a4370
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f390
leaq 0x25bc0e(%rip), %rax    # 0x48af9c
jmp 0x22f3b6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f3a4
leaq 0x1780b4(%rip), %rax    # 0x3a7456
jmp 0x22f3b6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f3d5
leaq 0x818a3(%rip), %rax     # 0x2b0c59
movq %rax, 0x574fbb(%rip)    # 0x7a4378
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f40a
leaq 0x268296(%rip), %rax    # 0x49769e
jmp 0x22f430
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f41e
leaq 0x18167b(%rip), %rax    # 0x3b0a97
jmp 0x22f430
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f44f
leaq 0x8bd09(%rip), %rax     # 0x2bb139
movq %rax, 0x574f49(%rip)    # 0x7a4380
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f484
leaq 0x2699dd(%rip), %rax    # 0x498e5f
jmp 0x22f4aa
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f498
leaq 0x182c3d(%rip), %rax    # 0x3b20d3
jmp 0x22f4aa
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f4c9
leaq 0x8d45b(%rip), %rax     # 0x2bc905
movq %rax, 0x574ed7(%rip)    # 0x7a4388
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22f4fe
leaq 0x26ae11(%rip), %rax    # 0x49a30d
jmp 0x22f524
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f512
leaq 0x184068(%rip), %rax    # 0x3b3578
jmp 0x22f524
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f543
leaq 0x8e92c(%rip), %rax     # 0x2bde50
movq %rax, 0x574e65(%rip)    # 0x7a4390
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_de_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_striped_profile_8_pointer = parasail_sg_de_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_striped_profile_8_pointer = parasail_sg_de_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_striped_profile_8_pointer = parasail_sg_de_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_striped_profile_8_pointer = parasail_sg_de_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_striped_profile_8_pointer = parasail_sg_de_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22f578
leaq 0x26c26f(%rip), %rax    # 0x49b7e5
jmp 0x22f59e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f58c
leaq 0x1854c3(%rip), %rax    # 0x3b4a4d
jmp 0x22f59e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f5bd
leaq 0x8ffe6(%rip), %rax     # 0x2bf584
movq %rax, 0x574df3(%rip)    # 0x7a4398
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_de_stats_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_scan_profile_64_pointer = parasail_sg_de_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_scan_profile_64_pointer = parasail_sg_de_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_scan_profile_64_pointer = parasail_sg_de_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_scan_profile_64_pointer = parasail_sg_de_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_scan_profile_64_pointer = parasail_sg_de_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_stats_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22f5f2
leaq 0x26f431(%rip), %rax    # 0x49ea21
jmp 0x22f618
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22f606
leaq 0x1885c8(%rip), %rax    # 0x3b7bcc
jmp 0x22f618
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x22f637
leaq 0x92f16(%rip), %rax     # 0x2c252e
movq %rax, 0x574d81(%rip)    # 0x7a43a0
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