LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_striped_8_pointer = parasail_sg_dx_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x232b7c
leaq 0x292d65(%rip), %rax    # 0x4c58df
jmp 0x232bab
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232b90
leaq 0x1a2a1d(%rip), %rax    # 0x3d55ab
jmp 0x232bab
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232ba4
leaq 0x68556(%rip), %rax     # 0x29b0f8
jmp 0x232bab
leaq 0x93cc4(%rip), %rax     # 0x2c686f
movq %rax, 0x5a79a6(%rip)    # 0x7da558
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_dx_dispatch.c
// Function: parasail_sg_dx_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_diag_64_pointer = parasail_sg_dx_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x232c05
leaq 0x2836bb(%rip), %rax    # 0x4b62be
jmp 0x232c34
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232c19
leaq 0x196649(%rip), %rax    # 0x3c9260
jmp 0x232c34
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232c2d
leaq 0x684cd(%rip), %rax     # 0x29b0f8
jmp 0x232c34
leaq 0x85305(%rip), %rax     # 0x2b7f39
movq %rax, 0x5a7925(%rip)    # 0x7da560
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_dx_dispatch.c
// Function: parasail_sg_dx_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_diag_32_pointer = parasail_sg_dx_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x232c8e
leaq 0x28530e(%rip), %rax    # 0x4b7f9a
jmp 0x232cbd
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232ca2
leaq 0x197e3a(%rip), %rax    # 0x3caada
jmp 0x232cbd
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232cb6
leaq 0x68444(%rip), %rax     # 0x29b0f8
jmp 0x232cbd
leaq 0x86f8b(%rip), %rax     # 0x2b9c48
movq %rax, 0x5a78a4(%rip)    # 0x7da568
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_dx_dispatch.c
// Function: parasail_sg_dx_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_diag_16_pointer = parasail_sg_dx_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x232d17
leaq 0x2876eb(%rip), %rax    # 0x4ba400
jmp 0x232d46
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232d2b
leaq 0x199981(%rip), %rax    # 0x3cc6aa
jmp 0x232d46
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232d3f
leaq 0x683bb(%rip), %rax     # 0x29b0f8
jmp 0x232d46
leaq 0x88d82(%rip), %rax     # 0x2bbac8
movq %rax, 0x5a7823(%rip)    # 0x7da570
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_dx_dispatch.c
// Function: parasail_sg_dx_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_diag_8_pointer = parasail_sg_dx_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x232da0
leaq 0x28a5b7(%rip), %rax    # 0x4bd355
jmp 0x232dcf
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232db4
leaq 0x19bc73(%rip), %rax    # 0x3cea25
jmp 0x232dcf
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232dc8
leaq 0x68332(%rip), %rax     # 0x29b0f8
jmp 0x232dcf
leaq 0x8b6b5(%rip), %rax     # 0x2be484
movq %rax, 0x5a77a2(%rip)    # 0x7da578
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x232e29
leaq 0x295298(%rip), %rax    # 0x4c80bf
jmp 0x232e58
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232e3d
leaq 0x1a5700(%rip), %rax    # 0x3d853b
jmp 0x232e58
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232e51
leaq 0x695a5(%rip), %rax     # 0x29c3f4
jmp 0x232e58
leaq 0x96e44(%rip), %rax     # 0x2c9c9c
movq %rax, 0x5a7721(%rip)    # 0x7da580
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x232eb2
leaq 0x29819d(%rip), %rax    # 0x4cb04d
jmp 0x232ee1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232ec6
leaq 0x1a872a(%rip), %rax    # 0x3db5ee
jmp 0x232ee1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232eda
leaq 0x6951c(%rip), %rax     # 0x29c3f4
jmp 0x232ee1
leaq 0x9a6e8(%rip), %rax     # 0x2cd5c9
movq %rax, 0x5a76a0(%rip)    # 0x7da588
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x232f3b
leaq 0x29b8e0(%rip), %rax    # 0x4ce819
jmp 0x232f6a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232f4f
leaq 0x1abaed(%rip), %rax    # 0x3dea3a
jmp 0x232f6a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232f63
leaq 0x69493(%rip), %rax     # 0x29c3f4
jmp 0x232f6a
leaq 0x9e291(%rip), %rax     # 0x2d11fb
movq %rax, 0x5a761f(%rip)    # 0x7da590
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x232fc4
leaq 0x29fb51(%rip), %rax    # 0x4d2b13
jmp 0x232ff3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x232fd8
leaq 0x1af2ed(%rip), %rax    # 0x3e22c3
jmp 0x232ff3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x232fec
leaq 0x6940a(%rip), %rax     # 0x29c3f4
jmp 0x232ff3
leaq 0xa278b(%rip), %rax     # 0x2d577e
movq %rax, 0x5a759e(%rip)    # 0x7da598
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x23304d
leaq 0x2b2b78(%rip), %rax    # 0x4e5bc3
jmp 0x23307c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x233061
leaq 0x1c02a1(%rip), %rax    # 0x3f3300
jmp 0x23307c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233075
leaq 0x68085(%rip), %rax     # 0x29b0f8
jmp 0x23307c
leaq 0xb69b5(%rip), %rax     # 0x2e9a31
movq %rax, 0x5a751d(%rip)    # 0x7da5a0
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x2330d6
leaq 0x2b582b(%rip), %rax    # 0x4e88ff
jmp 0x233105
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2330ea
leaq 0x1c3098(%rip), %rax    # 0x3f6180
jmp 0x233105
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2330fe
leaq 0x67ffc(%rip), %rax     # 0x29b0f8
jmp 0x233105
leaq 0xba2eb(%rip), %rax     # 0x2ed3f0
movq %rax, 0x5a749c(%rip)    # 0x7da5a8
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x23315f
leaq 0x2b8f38(%rip), %rax    # 0x4ec095
jmp 0x23318e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x233173
leaq 0x1c6220(%rip), %rax    # 0x3f9391
jmp 0x23318e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233187
leaq 0x67f73(%rip), %rax     # 0x29b0f8
jmp 0x23318e
leaq 0xbd997(%rip), %rax     # 0x2f0b25
movq %rax, 0x5a741b(%rip)    # 0x7da5b0
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x2331e8
leaq 0x2bd5c6(%rip), %rax    # 0x4f07ac
jmp 0x233217
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2331fc
leaq 0x1c9795(%rip), %rax    # 0x3fc98f
jmp 0x233217
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233210
leaq 0x67eea(%rip), %rax     # 0x29b0f8
jmp 0x233217
leaq 0xc1a34(%rip), %rax     # 0x2f4c4b
movq %rax, 0x5a739a(%rip)    # 0x7da5b8
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x233271
leaq 0x2a2c83(%rip), %rax    # 0x4d5ef2
jmp 0x2332a0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x233285
leaq 0x1b22ae(%rip), %rax    # 0x3e5531
jmp 0x2332a0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233299
leaq 0x67e61(%rip), %rax     # 0x29b0f8
jmp 0x2332a0
leaq 0xa629f(%rip), %rax     # 0x2d953f
movq %rax, 0x5a7319(%rip)    # 0x7da5c0
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x2332fa
leaq 0x2a61fb(%rip), %rax    # 0x4d94f3
jmp 0x233329
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23330e
leaq 0x1b538a(%rip), %rax    # 0x3e8696
jmp 0x233329
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233322
leaq 0x67dd8(%rip), %rax     # 0x29b0f8
jmp 0x233329
leaq 0xa9ca6(%rip), %rax     # 0x2dcfcf
movq %rax, 0x5a7298(%rip)    # 0x7da5c8
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x233383
leaq 0x2aa146(%rip), %rax    # 0x4dd4c7
jmp 0x2333b2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x233397
leaq 0x1b8a0c(%rip), %rax    # 0x3ebda1
jmp 0x2333b2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2333ab
leaq 0x67d4f(%rip), %rax     # 0x29b0f8
jmp 0x2333b2
leaq 0xad63b(%rip), %rax     # 0x2e09ed
movq %rax, 0x5a7217(%rip)    # 0x7da5d0
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x23340c
leaq 0x2aeed1(%rip), %rax    # 0x4e22db
jmp 0x23343b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x233420
leaq 0x1bca1f(%rip), %rax    # 0x3efe3d
jmp 0x23343b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233434
leaq 0x67cc6(%rip), %rax     # 0x29b0f8
jmp 0x23343b
leaq 0xb21e0(%rip), %rax     # 0x2e561b
movq %rax, 0x5a7196(%rip)    # 0x7da5d8
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_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x233495
leaq 0x2c079b(%rip), %rax    # 0x4f3c2e
jmp 0x2334c4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2334a9
leaq 0x1cb753(%rip), %rax    # 0x3febfa
jmp 0x2334c4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2334bd
leaq 0x68f39(%rip), %rax     # 0x29c3f4
jmp 0x2334c4
leaq 0xc52c0(%rip), %rax     # 0x2f8784
movq %rax, 0x5a7115(%rip)    # 0x7da5e0
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_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x23351e
leaq 0x2c23d5(%rip), %rax    # 0x4f58f1
jmp 0x23354d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x233532
leaq 0x1cd261(%rip), %rax    # 0x400791
jmp 0x23354d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233546
leaq 0x68eb0(%rip), %rax     # 0x29c3f4
jmp 0x23354d
leaq 0xc7293(%rip), %rax     # 0x2fa7e0
movq %rax, 0x5a7094(%rip)    # 0x7da5e8
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_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x2335a7
leaq 0x2c4f2b(%rip), %rax    # 0x4f84d0
jmp 0x2335d6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2335bb
leaq 0x1cf21b(%rip), %rax    # 0x4027d4
jmp 0x2335d6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2335cf
leaq 0x68e27(%rip), %rax     # 0x29c3f4
jmp 0x2335d6
leaq 0xc969c(%rip), %rax     # 0x2fcc72
movq %rax, 0x5a7013(%rip)    # 0x7da5f0
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_dx_dispatch.c
// Function: parasail_sg_dx_table_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x233630
leaq 0x2c8d3e(%rip), %rax    # 0x4fc36c
jmp 0x23365f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x233644
leaq 0x1d198b(%rip), %rax    # 0x404fcd
jmp 0x23365f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x233658
leaq 0x68d9e(%rip), %rax     # 0x29c3f4
jmp 0x23365f
leaq 0xcc75e(%rip), %rax     # 0x2ffdbd
movq %rax, 0x5a6f92(%rip)    # 0x7da5f8
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_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x2336b9
leaq 0x2d8649(%rip), %rax    # 0x50bd00
jmp 0x2336e8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2336cd
leaq 0x1dceb6(%rip), %rax    # 0x410581
jmp 0x2336e8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2336e1
leaq 0x67a19(%rip), %rax     # 0x29b0f8
jmp 0x2336e8
leaq 0xd98e3(%rip), %rax     # 0x30cfcb
movq %rax, 0x5a6f11(%rip)    # 0x7da600
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