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_striped_32_dispatcher
parasail_result_t* parasail_sg_de_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_striped_32_pointer = parasail_sg_de_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_striped_32_pointer = parasail_sg_de_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_striped_32_pointer = parasail_sg_de_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_striped_32_pointer = parasail_sg_de_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_striped_32_pointer = parasail_sg_de_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x22c7e2
leaq 0x26c534(%rip), %rax    # 0x498d14
jmp 0x22c811
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22c7f6
leaq 0x185794(%rip), %rax    # 0x3b1f88
jmp 0x22c811
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22c80a
leaq 0x6d307(%rip), %rax     # 0x299b0f
jmp 0x22c811
leaq 0x8ffa9(%rip), %rax     # 0x2bc7ba
movq %rax, 0x5778d0(%rip)    # 0x7a40e8
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_striped_16_dispatcher
parasail_result_t* parasail_sg_de_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_striped_16_pointer = parasail_sg_de_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_striped_16_pointer = parasail_sg_de_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_striped_16_pointer = parasail_sg_de_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_striped_16_pointer = parasail_sg_de_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_striped_16_pointer = parasail_sg_de_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x22c86b
leaq 0x26d959(%rip), %rax    # 0x49a1c2
jmp 0x22c89a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22c87f
leaq 0x186bb0(%rip), %rax    # 0x3b342d
jmp 0x22c89a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22c893
leaq 0x6d27e(%rip), %rax     # 0x299b0f
jmp 0x22c89a
leaq 0x9146b(%rip), %rax     # 0x2bdd05
movq %rax, 0x57784f(%rip)    # 0x7a40f0
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_striped_8_dispatcher
parasail_result_t* parasail_sg_de_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_striped_8_pointer = parasail_sg_de_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_striped_8_pointer = parasail_sg_de_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_striped_8_pointer = parasail_sg_de_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_striped_8_pointer = parasail_sg_de_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_striped_8_pointer = parasail_sg_de_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x22c8f4
leaq 0x26eda8(%rip), %rax    # 0x49b69a
jmp 0x22c923
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22c908
leaq 0x187ffc(%rip), %rax    # 0x3b4902
jmp 0x22c923
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22c91c
leaq 0x6d1f5(%rip), %rax     # 0x299b0f
jmp 0x22c923
leaq 0x92b16(%rip), %rax     # 0x2bf439
movq %rax, 0x5777ce(%rip)    # 0x7a40f8
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_diag_64_dispatcher
parasail_result_t* parasail_sg_de_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_diag_64_pointer = parasail_sg_de_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_diag_64_pointer = parasail_sg_de_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_diag_64_pointer = parasail_sg_de_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_diag_64_pointer = parasail_sg_de_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_diag_64_pointer = parasail_sg_de_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x22c97d
leaq 0x260597(%rip), %rax    # 0x48cf12
jmp 0x22c9ac
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22c991
leaq 0x17c4de(%rip), %rax    # 0x3a8e6d
jmp 0x22c9ac
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22c9a5
leaq 0x6d16c(%rip), %rax     # 0x299b0f
jmp 0x22c9ac
leaq 0x8606f(%rip), %rax     # 0x2b2a1b
movq %rax, 0x57774d(%rip)    # 0x7a4100
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_diag_32_dispatcher
parasail_result_t* parasail_sg_de_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_diag_32_pointer = parasail_sg_de_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_diag_32_pointer = parasail_sg_de_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_diag_32_pointer = parasail_sg_de_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_diag_32_pointer = parasail_sg_de_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_diag_32_pointer = parasail_sg_de_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x22ca06
leaq 0x262515(%rip), %rax    # 0x48ef19
jmp 0x22ca35
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ca1a
leaq 0x17de59(%rip), %rax    # 0x3aa871
jmp 0x22ca35
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ca2e
leaq 0x6d0e3(%rip), %rax     # 0x299b0f
jmp 0x22ca35
leaq 0x87d05(%rip), %rax     # 0x2b473a
movq %rax, 0x5776cc(%rip)    # 0x7a4108
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_diag_16_dispatcher
parasail_result_t* parasail_sg_de_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_diag_16_pointer = parasail_sg_de_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_diag_16_pointer = parasail_sg_de_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_diag_16_pointer = parasail_sg_de_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_diag_16_pointer = parasail_sg_de_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_diag_16_pointer = parasail_sg_de_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x22ca8f
leaq 0x264956(%rip), %rax    # 0x4913e3
jmp 0x22cabe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22caa3
leaq 0x17fa18(%rip), %rax    # 0x3ac4b9
jmp 0x22cabe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22cab7
leaq 0x6d05a(%rip), %rax     # 0x299b0f
jmp 0x22cabe
leaq 0x89adb(%rip), %rax     # 0x2b6599
movq %rax, 0x57764b(%rip)    # 0x7a4110
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_diag_8_dispatcher
parasail_result_t* parasail_sg_de_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_diag_8_pointer = parasail_sg_de_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_diag_8_pointer = parasail_sg_de_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_diag_8_pointer = parasail_sg_de_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_diag_8_pointer = parasail_sg_de_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_diag_8_pointer = parasail_sg_de_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x22cb18
leaq 0x267f83(%rip), %rax    # 0x494a99
jmp 0x22cb47
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22cb2c
leaq 0x181e39(%rip), %rax    # 0x3ae963
jmp 0x22cb47
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22cb40
leaq 0x6cfd1(%rip), %rax     # 0x299b0f
jmp 0x22cb47
leaq 0x8c2d4(%rip), %rax     # 0x2b8e1b
movq %rax, 0x5775ca(%rip)    # 0x7a4118
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_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_scan_64_pointer = parasail_sg_de_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_scan_64_pointer = parasail_sg_de_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_scan_64_pointer = parasail_sg_de_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_scan_64_pointer = parasail_sg_de_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_scan_64_pointer = parasail_sg_de_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_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 0x22cba1
leaq 0x271d37(%rip), %rax    # 0x49e8d6
jmp 0x22cbd0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22cbb5
leaq 0x18aece(%rip), %rax    # 0x3b7a81
jmp 0x22cbd0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22cbc9
leaq 0x6ddc6(%rip), %rax     # 0x29a98d
jmp 0x22cbd0
leaq 0x95813(%rip), %rax     # 0x2c23e3
movq %rax, 0x577549(%rip)    # 0x7a4120
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_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_scan_32_pointer = parasail_sg_de_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_scan_32_pointer = parasail_sg_de_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_scan_32_pointer = parasail_sg_de_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_scan_32_pointer = parasail_sg_de_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_scan_32_pointer = parasail_sg_de_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_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 0x22cc2a
leaq 0x275111(%rip), %rax    # 0x4a1d39
jmp 0x22cc59
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22cc3e
leaq 0x18def9(%rip), %rax    # 0x3bab35
jmp 0x22cc59
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22cc52
leaq 0x6dd3d(%rip), %rax     # 0x29a98d
jmp 0x22cc59
leaq 0x98e67(%rip), %rax     # 0x2c5ac0
movq %rax, 0x5774c8(%rip)    # 0x7a4128
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_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_scan_16_pointer = parasail_sg_de_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_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 0x22ccb3
leaq 0x277f24(%rip), %rax    # 0x4a4bd5
jmp 0x22cce2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ccc7
leaq 0x190cab(%rip), %rax    # 0x3bd970
jmp 0x22cce2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ccdb
leaq 0x6dcb4(%rip), %rax     # 0x29a98d
jmp 0x22cce2
leaq 0x9c0b3(%rip), %rax     # 0x2c8d95
movq %rax, 0x577447(%rip)    # 0x7a4130
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_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_scan_8_pointer = parasail_sg_de_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_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 0x22cd3c
leaq 0x27ad5d(%rip), %rax    # 0x4a7a97
jmp 0x22cd6b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22cd50
leaq 0x193b00(%rip), %rax    # 0x3c084e
jmp 0x22cd6b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22cd64
leaq 0x6dc2b(%rip), %rax     # 0x29a98d
jmp 0x22cd6b
leaq 0x9f4c3(%rip), %rax     # 0x2cc22e
movq %rax, 0x5773c6(%rip)    # 0x7a4138
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_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_striped_64_pointer = parasail_sg_de_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22cdc5
leaq 0x28f75f(%rip), %rax    # 0x4bc522
jmp 0x22cdf4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22cdd9
leaq 0x1a51e7(%rip), %rax    # 0x3d1fbe
jmp 0x22cdf4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22cded
leaq 0x6cd24(%rip), %rax     # 0x299b0f
jmp 0x22cdf4
leaq 0xb2ca9(%rip), %rax     # 0x2dfa9d
movq %rax, 0x577345(%rip)    # 0x7a4140
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_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_striped_32_pointer = parasail_sg_de_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22ce4e
leaq 0x2926e4(%rip), %rax    # 0x4bf530
jmp 0x22ce7d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ce62
leaq 0x1a7f6c(%rip), %rax    # 0x3d4dcc
jmp 0x22ce7d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ce76
leaq 0x6cc9b(%rip), %rax     # 0x299b0f
jmp 0x22ce7d
leaq 0xb6090(%rip), %rax     # 0x2e2f0d
movq %rax, 0x5772c4(%rip)    # 0x7a4148
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_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_striped_16_pointer = parasail_sg_de_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22ced7
leaq 0x29520b(%rip), %rax    # 0x4c20e0
jmp 0x22cf06
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ceeb
leaq 0x1aaaff(%rip), %rax    # 0x3d79e8
jmp 0x22cf06
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ceff
leaq 0x6cc12(%rip), %rax     # 0x299b0f
jmp 0x22cf06
leaq 0xb8fd7(%rip), %rax     # 0x2e5edd
movq %rax, 0x577243(%rip)    # 0x7a4150
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_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_striped_8_pointer = parasail_sg_de_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22cf60
leaq 0x297dcb(%rip), %rax    # 0x4c4d29
jmp 0x22cf8f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22cf74
leaq 0x1ad736(%rip), %rax    # 0x3da6a8
jmp 0x22cf8f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22cf88
leaq 0x6cb89(%rip), %rax     # 0x299b0f
jmp 0x22cf8f
leaq 0xbc16b(%rip), %rax     # 0x2e90fa
movq %rax, 0x5771c2(%rip)    # 0x7a4158
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_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_diag_64_pointer = parasail_sg_de_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22cfe9
leaq 0x27e4b5(%rip), %rax    # 0x4ab49c
jmp 0x22d018
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22cffd
leaq 0x196ca9(%rip), %rax    # 0x3c3ca4
jmp 0x22d018
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d011
leaq 0x6cb00(%rip), %rax     # 0x299b0f
jmp 0x22d018
leaq 0xa2e06(%rip), %rax     # 0x2cfe1e
movq %rax, 0x577141(%rip)    # 0x7a4160
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_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_de_stats_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_diag_32_pointer = parasail_sg_de_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22d072
leaq 0x281e40(%rip), %rax    # 0x4aeeb0
jmp 0x22d0a1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d086
leaq 0x199ef5(%rip), %rax    # 0x3c6f79
jmp 0x22d0a1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d09a
leaq 0x6ca77(%rip), %rax     # 0x299b0f
jmp 0x22d0a1
leaq 0xa674e(%rip), %rax     # 0x2d37ef
movq %rax, 0x5770c0(%rip)    # 0x7a4168
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_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_de_stats_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_diag_16_pointer = parasail_sg_de_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22d0fb
leaq 0x285cf0(%rip), %rax    # 0x4b2de9
jmp 0x22d12a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d10f
leaq 0x19d5a9(%rip), %rax    # 0x3ca6b6
jmp 0x22d12a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d123
leaq 0x6c9ee(%rip), %rax     # 0x299b0f
jmp 0x22d12a
leaq 0xaa1a9(%rip), %rax     # 0x2d72d3
movq %rax, 0x57703f(%rip)    # 0x7a4170
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_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_de_stats_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_diag_8_pointer = parasail_sg_de_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x22d184
leaq 0x28aff3(%rip), %rax    # 0x4b8175
jmp 0x22d1b3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d198
leaq 0x1a1639(%rip), %rax    # 0x3ce7cf
jmp 0x22d1b3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d1ac
leaq 0x6c965(%rip), %rax     # 0x299b0f
jmp 0x22d1b3
leaq 0xae984(%rip), %rax     # 0x2dbb37
movq %rax, 0x576fbe(%rip)    # 0x7a4178
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_table_scan_64_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_scan_64_pointer = parasail_sg_de_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_table_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 0x22d20d
leaq 0x29b78b(%rip), %rax    # 0x4c8996
jmp 0x22d23c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d221
leaq 0x1af852(%rip), %rax    # 0x3dca71
jmp 0x22d23c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d235
leaq 0x6d75a(%rip), %rax     # 0x29a98d
jmp 0x22d23c
leaq 0xbf49f(%rip), %rax     # 0x2ec6db
movq %rax, 0x576f3d(%rip)    # 0x7a4180
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_table_scan_32_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_scan_32_pointer = parasail_sg_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_table_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 0x22d296
leaq 0x29d69c(%rip), %rax    # 0x4ca930
jmp 0x22d2c5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d2aa
leaq 0x1b114e(%rip), %rax    # 0x3de3f6
jmp 0x22d2c5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d2be
leaq 0x6d6d1(%rip), %rax     # 0x29a98d
jmp 0x22d2c5
leaq 0xc0ffc(%rip), %rax     # 0x2ee2c1
movq %rax, 0x576ebc(%rip)    # 0x7a4188
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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_scan_16_pointer = parasail_sg_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_table_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 0x22d31f
leaq 0x29f4b0(%rip), %rax    # 0x4cc7cd
jmp 0x22d34e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d333
leaq 0x1b2b84(%rip), %rax    # 0x3dfeb5
jmp 0x22d34e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d347
leaq 0x6d648(%rip), %rax     # 0x29a98d
jmp 0x22d34e
leaq 0xc2b41(%rip), %rax     # 0x2efe8f
movq %rax, 0x576e3b(%rip)    # 0x7a4190
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