LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e3bd
leaq 0x2b77ed(%rip), %rax    # 0x4e5ba8
jmp 0x22e3ec
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e3d1
leaq 0x1c4f16(%rip), %rax    # 0x3f32e5
jmp 0x22e3ec
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e3e5
leaq 0x6ccfa(%rip), %rax     # 0x29b0dd
jmp 0x22e3ec
leaq 0xbb62a(%rip), %rax     # 0x2e9a16
movq %rax, 0x5abd4d(%rip)    # 0x7da140
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e446
leaq 0x2ba4a0(%rip), %rax    # 0x4e88e4
jmp 0x22e475
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e45a
leaq 0x1c7d0d(%rip), %rax    # 0x3f6165
jmp 0x22e475
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e46e
leaq 0x6cc71(%rip), %rax     # 0x29b0dd
jmp 0x22e475
leaq 0xbef60(%rip), %rax     # 0x2ed3d5
movq %rax, 0x5abccc(%rip)    # 0x7da148
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e4cf
leaq 0x2bdbad(%rip), %rax    # 0x4ec07a
jmp 0x22e4fe
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e4e3
leaq 0x1cae95(%rip), %rax    # 0x3f9376
jmp 0x22e4fe
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e4f7
leaq 0x6cbe8(%rip), %rax     # 0x29b0dd
jmp 0x22e4fe
leaq 0xc260c(%rip), %rax     # 0x2f0b0a
movq %rax, 0x5abc4b(%rip)    # 0x7da150
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e558
leaq 0x2c223b(%rip), %rax    # 0x4f0791
jmp 0x22e587
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e56c
leaq 0x1ce40a(%rip), %rax    # 0x3fc974
jmp 0x22e587
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e580
leaq 0x6cb5f(%rip), %rax     # 0x29b0dd
jmp 0x22e587
leaq 0xc66a9(%rip), %rax     # 0x2f4c30
movq %rax, 0x5abbca(%rip)    # 0x7da158
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e5e1
leaq 0x2a78f8(%rip), %rax    # 0x4d5ed7
jmp 0x22e610
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e5f5
leaq 0x1b6f23(%rip), %rax    # 0x3e5516
jmp 0x22e610
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e609
leaq 0x6cad6(%rip), %rax     # 0x29b0dd
jmp 0x22e610
leaq 0xaaf14(%rip), %rax     # 0x2d9524
movq %rax, 0x5abb49(%rip)    # 0x7da160
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e66a
leaq 0x2aae70(%rip), %rax    # 0x4d94d8
jmp 0x22e699
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e67e
leaq 0x1b9fff(%rip), %rax    # 0x3e867b
jmp 0x22e699
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e692
leaq 0x6ca4d(%rip), %rax     # 0x29b0dd
jmp 0x22e699
leaq 0xae91b(%rip), %rax     # 0x2dcfb4
movq %rax, 0x5abac8(%rip)    # 0x7da168
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e6f3
leaq 0x2aedbb(%rip), %rax    # 0x4dd4ac
jmp 0x22e722
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e707
leaq 0x1bd681(%rip), %rax    # 0x3ebd86
jmp 0x22e722
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e71b
leaq 0x6c9c4(%rip), %rax     # 0x29b0dd
jmp 0x22e722
leaq 0xb22b0(%rip), %rax     # 0x2e09d2
movq %rax, 0x5aba47(%rip)    # 0x7da170
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e77c
leaq 0x2b3b46(%rip), %rax    # 0x4e22c0
jmp 0x22e7ab
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e790
leaq 0x1c1694(%rip), %rax    # 0x3efe22
jmp 0x22e7ab
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e7a4
leaq 0x6c93b(%rip), %rax     # 0x29b0dd
jmp 0x22e7ab
leaq 0xb6e55(%rip), %rax     # 0x2e5600
movq %rax, 0x5ab9c6(%rip)    # 0x7da178
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e805
leaq 0x2c5410(%rip), %rax    # 0x4f3c13
jmp 0x22e834
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e819
leaq 0x1d03c8(%rip), %rax    # 0x3febdf
jmp 0x22e834
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e82d
leaq 0x6dbae(%rip), %rax     # 0x29c3d9
jmp 0x22e834
leaq 0xc9f35(%rip), %rax     # 0x2f8769
movq %rax, 0x5ab945(%rip)    # 0x7da180
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e88e
leaq 0x2c704a(%rip), %rax    # 0x4f58d6
jmp 0x22e8bd
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e8a2
leaq 0x1d1ed6(%rip), %rax    # 0x400776
jmp 0x22e8bd
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e8b6
leaq 0x6db25(%rip), %rax     # 0x29c3d9
jmp 0x22e8bd
leaq 0xcbf08(%rip), %rax     # 0x2fa7c5
movq %rax, 0x5ab8c4(%rip)    # 0x7da188
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x22e917
leaq 0x2c9ba0(%rip), %rax    # 0x4f84b5
jmp 0x22e946
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e92b
leaq 0x1d3e90(%rip), %rax    # 0x4027b9
jmp 0x22e946
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e93f
leaq 0x6da9c(%rip), %rax     # 0x29c3d9
jmp 0x22e946
leaq 0xce311(%rip), %rax     # 0x2fcc57
movq %rax, 0x5ab843(%rip)    # 0x7da190
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_scan_8_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_scan_8_pointer = parasail_sg_de_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22e9a0
leaq 0x2cd9b3(%rip), %rax    # 0x4fc351
jmp 0x22e9cf
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22e9b4
leaq 0x1d6600(%rip), %rax    # 0x404fb2
jmp 0x22e9cf
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22e9c8
leaq 0x6da13(%rip), %rax     # 0x29c3d9
jmp 0x22e9cf
leaq 0xd13d3(%rip), %rax     # 0x2ffda2
movq %rax, 0x5ab7c2(%rip)    # 0x7da198
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_striped_64_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_striped_64_pointer = parasail_sg_de_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22ea29
leaq 0x2dd2be(%rip), %rax    # 0x50bce5
jmp 0x22ea58
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22ea3d
leaq 0x1e1b2b(%rip), %rax    # 0x410566
jmp 0x22ea58
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ea51
leaq 0x6c68e(%rip), %rax     # 0x29b0dd
jmp 0x22ea58
leaq 0xde558(%rip), %rax     # 0x30cfb0
movq %rax, 0x5ab741(%rip)    # 0x7da1a0
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_striped_32_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_striped_32_pointer = parasail_sg_de_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22eab2
leaq 0x2decd5(%rip), %rax    # 0x50d785
jmp 0x22eae1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22eac6
leaq 0x1e3396(%rip), %rax    # 0x411e5a
jmp 0x22eae1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22eada
leaq 0x6c605(%rip), %rax     # 0x29b0dd
jmp 0x22eae1
leaq 0xe02a9(%rip), %rax     # 0x30ed8a
movq %rax, 0x5ab6c0(%rip)    # 0x7da1a8
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_striped_16_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_striped_16_pointer = parasail_sg_de_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22eb3b
leaq 0x2e1881(%rip), %rax    # 0x5103ba
jmp 0x22eb6a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22eb4f
leaq 0x1e526a(%rip), %rax    # 0x413db7
jmp 0x22eb6a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22eb63
leaq 0x6c57c(%rip), %rax     # 0x29b0dd
jmp 0x22eb6a
leaq 0xe2575(%rip), %rax     # 0x3110df
movq %rax, 0x5ab63f(%rip)    # 0x7da1b0
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_striped_8_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_striped_8_pointer = parasail_sg_de_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22ebc4
leaq 0x2e58f3(%rip), %rax    # 0x5144b5
jmp 0x22ebf3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22ebd8
leaq 0x1e7b57(%rip), %rax    # 0x41672d
jmp 0x22ebf3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ebec
leaq 0x6c4f3(%rip), %rax     # 0x29b0dd
jmp 0x22ebf3
leaq 0xe5740(%rip), %rax     # 0x314333
movq %rax, 0x5ab5be(%rip)    # 0x7da1b8
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_diag_64_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_diag_64_pointer = parasail_sg_de_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22ec4d
leaq 0x2cf9fc(%rip), %rax    # 0x4fe647
jmp 0x22ec7c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22ec61
leaq 0x1d810e(%rip), %rax    # 0x406d6d
jmp 0x22ec7c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ec75
leaq 0x6c46a(%rip), %rax     # 0x29b0dd
jmp 0x22ec7c
leaq 0xd35f2(%rip), %rax     # 0x30226e
movq %rax, 0x5ab53d(%rip)    # 0x7da1c0
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_diag_32_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_diag_32_pointer = parasail_sg_de_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22ecd6
leaq 0x2d1d0f(%rip), %rax    # 0x5009e3
jmp 0x22ed05
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22ecea
leaq 0x1d9c6d(%rip), %rax    # 0x408955
jmp 0x22ed05
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ecfe
leaq 0x6c3e1(%rip), %rax     # 0x29b0dd
jmp 0x22ed05
leaq 0xd5662(%rip), %rax     # 0x304367
movq %rax, 0x5ab4bc(%rip)    # 0x7da1c8
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_diag_16_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_diag_16_pointer = parasail_sg_de_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22ed5f
leaq 0x2d510b(%rip), %rax    # 0x503e68
jmp 0x22ed8e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22ed73
leaq 0x1dbf00(%rip), %rax    # 0x40ac71
jmp 0x22ed8e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ed87
leaq 0x6c358(%rip), %rax     # 0x29b0dd
jmp 0x22ed8e
leaq 0xd7b55(%rip), %rax     # 0x3068e3
movq %rax, 0x5ab43b(%rip)    # 0x7da1d0
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_diag_8_dispatcher
parasail_result_t* parasail_sg_de_table_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_table_diag_8_pointer = parasail_sg_de_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_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 0x5c8fdb
testl %eax, %eax
je 0x22ede8
leaq 0x2da128(%rip), %rax    # 0x508f0e
jmp 0x22ee17
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22edfc
leaq 0x1df266(%rip), %rax    # 0x40e060
jmp 0x22ee17
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ee10
leaq 0x6c2cf(%rip), %rax     # 0x29b0dd
jmp 0x22ee17
leaq 0xdb4d0(%rip), %rax     # 0x30a2e7
movq %rax, 0x5ab3ba(%rip)    # 0x7da1d8
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x22ee71
leaq 0x2e890a(%rip), %rax    # 0x517779
jmp 0x22eea0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22ee85
leaq 0x1eb04e(%rip), %rax    # 0x419ed1
jmp 0x22eea0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ee99
leaq 0x6d542(%rip), %rax     # 0x29c3d9
jmp 0x22eea0
leaq 0xe902d(%rip), %rax     # 0x317ecd
movq %rax, 0x5ab339(%rip)    # 0x7da1e0
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_O3/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_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 0x5c8fdb
testl %eax, %eax
je 0x22eefa
leaq 0x2ebf5b(%rip), %rax    # 0x51ae53
jmp 0x22ef29
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22ef0e
leaq 0x1ee4bd(%rip), %rax    # 0x41d3c9
jmp 0x22ef29
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22ef22
leaq 0x6d4b9(%rip), %rax     # 0x29c3d9
jmp 0x22ef29
leaq 0xecd7d(%rip), %rax     # 0x31bca6
movq %rax, 0x5ab2b8(%rip)    # 0x7da1e8
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