LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x231bf0
leaq 0x293156(%rip), %rax    # 0x4c4d44
jmp 0x231c1f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231c04
leaq 0x1a8ac1(%rip), %rax    # 0x3da6c3
jmp 0x231c1f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231c18
leaq 0x67f14(%rip), %rax     # 0x299b2a
jmp 0x231c1f
leaq 0xb74f6(%rip), %rax     # 0x2e9115
movq %rax, 0x572992(%rip)    # 0x7a45b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x231c79
leaq 0x279840(%rip), %rax    # 0x4ab4b7
jmp 0x231ca8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231c8d
leaq 0x192034(%rip), %rax    # 0x3c3cbf
jmp 0x231ca8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231ca1
leaq 0x67e8b(%rip), %rax     # 0x299b2a
jmp 0x231ca8
leaq 0x9e191(%rip), %rax     # 0x2cfe39
movq %rax, 0x572911(%rip)    # 0x7a45c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x231d02
leaq 0x27d1cb(%rip), %rax    # 0x4aeecb
jmp 0x231d31
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231d16
leaq 0x195280(%rip), %rax    # 0x3c6f94
jmp 0x231d31
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231d2a
leaq 0x67e02(%rip), %rax     # 0x299b2a
jmp 0x231d31
leaq 0xa1ad9(%rip), %rax     # 0x2d380a
movq %rax, 0x572890(%rip)    # 0x7a45c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x231d8b
leaq 0x28107b(%rip), %rax    # 0x4b2e04
jmp 0x231dba
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231d9f
leaq 0x198934(%rip), %rax    # 0x3ca6d1
jmp 0x231dba
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231db3
leaq 0x67d79(%rip), %rax     # 0x299b2a
jmp 0x231dba
leaq 0xa5534(%rip), %rax     # 0x2d72ee
movq %rax, 0x57280f(%rip)    # 0x7a45d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x231e14
leaq 0x28637e(%rip), %rax    # 0x4b8190
jmp 0x231e43
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231e28
leaq 0x19c9c4(%rip), %rax    # 0x3ce7ea
jmp 0x231e43
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231e3c
leaq 0x67cf0(%rip), %rax     # 0x299b2a
jmp 0x231e43
leaq 0xa9d0f(%rip), %rax     # 0x2dbb52
movq %rax, 0x57278e(%rip)    # 0x7a45d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x231e9d
leaq 0x296b16(%rip), %rax    # 0x4c89b1
jmp 0x231ecc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231eb1
leaq 0x1aabdd(%rip), %rax    # 0x3dca8c
jmp 0x231ecc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231ec5
leaq 0x68ae5(%rip), %rax     # 0x29a9a8
jmp 0x231ecc
leaq 0xba82a(%rip), %rax     # 0x2ec6f6
movq %rax, 0x57270d(%rip)    # 0x7a45e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x231f26
leaq 0x298a27(%rip), %rax    # 0x4ca94b
jmp 0x231f55
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231f3a
leaq 0x1ac4d9(%rip), %rax    # 0x3de411
jmp 0x231f55
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231f4e
leaq 0x68a5c(%rip), %rax     # 0x29a9a8
jmp 0x231f55
leaq 0xbc387(%rip), %rax     # 0x2ee2dc
movq %rax, 0x57268c(%rip)    # 0x7a45e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x231faf
leaq 0x29a83b(%rip), %rax    # 0x4cc7e8
jmp 0x231fde
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x231fc3
leaq 0x1adf0f(%rip), %rax    # 0x3dfed0
jmp 0x231fde
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x231fd7
leaq 0x689d3(%rip), %rax     # 0x29a9a8
jmp 0x231fde
leaq 0xbdecc(%rip), %rax     # 0x2efeaa
movq %rax, 0x57260b(%rip)    # 0x7a45f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x232038
leaq 0x29cb5a(%rip), %rax    # 0x4ceb90
jmp 0x232067
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23204c
leaq 0x1afd48(%rip), %rax    # 0x3e1d92
jmp 0x232067
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232060
leaq 0x6894a(%rip), %rax     # 0x29a9a8
jmp 0x232067
leaq 0xc000d(%rip), %rax     # 0x2f2074
movq %rax, 0x57258a(%rip)    # 0x7a45f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2320c1
leaq 0x2adeaa(%rip), %rax    # 0x4dff69
jmp 0x2320f0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2320d5
leaq 0x1bb9f8(%rip), %rax    # 0x3edacb
jmp 0x2320f0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2320e9
leaq 0x67a43(%rip), %rax     # 0x299b2a
jmp 0x2320f0
leaq 0xccd3f(%rip), %rax     # 0x2fee2f
movq %rax, 0x572509(%rip)    # 0x7a4600
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x23214a
leaq 0x2af9fe(%rip), %rax    # 0x4e1b46
jmp 0x232179
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23215e
leaq 0x1bd195(%rip), %rax    # 0x3ef2f1
jmp 0x232179
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232172
leaq 0x679ba(%rip), %rax     # 0x299b2a
jmp 0x232179
leaq 0xce729(%rip), %rax     # 0x3008a2
movq %rax, 0x572488(%rip)    # 0x7a4608
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x2321d3
leaq 0x2b196c(%rip), %rax    # 0x4e3b3d
jmp 0x232202
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2321e7
leaq 0x1bea78(%rip), %rax    # 0x3f0c5d
jmp 0x232202
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2321fb
leaq 0x67931(%rip), %rax     # 0x299b2a
jmp 0x232202
leaq 0xd00d1(%rip), %rax     # 0x3022d3
movq %rax, 0x572407(%rip)    # 0x7a4610
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_striped_8_pointer = parasail_sg_dx_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_8_pointer = parasail_sg_dx_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_8_pointer = parasail_sg_dx_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_8_pointer = parasail_sg_dx_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_8_pointer = parasail_sg_dx_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_table_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x23225c
leaq 0x2b3f77(%rip), %rax    # 0x4e61d1
jmp 0x23228b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232270
leaq 0x1c09c7(%rip), %rax    # 0x3f2c35
jmp 0x23228b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232284
leaq 0x678a8(%rip), %rax     # 0x299b2a
jmp 0x23228b
leaq 0xd23e9(%rip), %rax     # 0x304674
movq %rax, 0x572386(%rip)    # 0x7a4618
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_diag_64_pointer = parasail_sg_dx_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_diag_64_pointer = parasail_sg_dx_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_diag_64_pointer = parasail_sg_dx_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_diag_64_pointer = parasail_sg_dx_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_diag_64_pointer = parasail_sg_dx_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_table_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x2322e5
leaq 0x29f0ef(%rip), %rax    # 0x4d13d2
jmp 0x232314
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2322f9
leaq 0x1b19a7(%rip), %rax    # 0x3e3c9e
jmp 0x232314
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23230d
leaq 0x6781f(%rip), %rax     # 0x299b2a
jmp 0x232314
leaq 0xc2058(%rip), %rax     # 0x2f436c
movq %rax, 0x572305(%rip)    # 0x7a4620
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_diag_32_pointer = parasail_sg_dx_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_diag_32_pointer = parasail_sg_dx_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_diag_32_pointer = parasail_sg_dx_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_diag_32_pointer = parasail_sg_dx_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_diag_32_pointer = parasail_sg_dx_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_table_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x23236e
leaq 0x2a182a(%rip), %rax    # 0x4d3b96
jmp 0x23239d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232382
leaq 0x1b3696(%rip), %rax    # 0x3e5a16
jmp 0x23239d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232396
leaq 0x67796(%rip), %rax     # 0x299b2a
jmp 0x23239d
leaq 0xc40d6(%rip), %rax     # 0x2f6473
movq %rax, 0x572284(%rip)    # 0x7a4628
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_diag_16_pointer = parasail_sg_dx_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_diag_16_pointer = parasail_sg_dx_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_diag_16_pointer = parasail_sg_dx_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_diag_16_pointer = parasail_sg_dx_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_diag_16_pointer = parasail_sg_dx_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_table_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x2323f7
leaq 0x2a4c25(%rip), %rax    # 0x4d701a
jmp 0x232426
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23240b
leaq 0x1b5a4b(%rip), %rax    # 0x3e7e54
jmp 0x232426
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23241f
leaq 0x6770d(%rip), %rax     # 0x299b2a
jmp 0x232426
leaq 0xc6732(%rip), %rax     # 0x2f8b58
movq %rax, 0x572203(%rip)    # 0x7a4630
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_table_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_table_diag_8_pointer = parasail_sg_dx_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_diag_8_pointer = parasail_sg_dx_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_diag_8_pointer = parasail_sg_dx_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_diag_8_pointer = parasail_sg_dx_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_diag_8_pointer = parasail_sg_dx_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_table_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x232480
leaq 0x2aa0df(%rip), %rax    # 0x4dc55d
jmp 0x2324af
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232494
leaq 0x1b8e0b(%rip), %rax    # 0x3eb29d
jmp 0x2324af
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2324a8
leaq 0x67684(%rip), %rax     # 0x299b2a
jmp 0x2324af
leaq 0xc9f2f(%rip), %rax     # 0x2fc3de
movq %rax, 0x572182(%rip)    # 0x7a4638
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_table_scan_64_pointer = parasail_sg_dx_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_64_pointer = parasail_sg_dx_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_64_pointer = parasail_sg_dx_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_64_pointer = parasail_sg_dx_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_64_pointer = parasail_sg_dx_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x232509
leaq 0x2b7952(%rip), %rax    # 0x4e9e59
jmp 0x232538
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23251d
leaq 0x1c410f(%rip), %rax    # 0x3f662a
jmp 0x232538
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232531
leaq 0x68479(%rip), %rax     # 0x29a9a8
jmp 0x232538
leaq 0xd57dd(%rip), %rax     # 0x307d15
movq %rax, 0x572101(%rip)    # 0x7a4640
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_table_scan_32_pointer = parasail_sg_dx_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_32_pointer = parasail_sg_dx_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_32_pointer = parasail_sg_dx_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_32_pointer = parasail_sg_dx_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_32_pointer = parasail_sg_dx_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x594f9c
testl %eax, %eax
je 0x232592
leaq 0x2bb425(%rip), %rax    # 0x4ed9b5
jmp 0x2325c1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2325a6
leaq 0x1c75a6(%rip), %rax    # 0x3f9b4a
jmp 0x2325c1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2325ba
leaq 0x683f0(%rip), %rax     # 0x29a9a8
jmp 0x2325c1
leaq 0xd925e(%rip), %rax     # 0x30b81f
movq %rax, 0x572080(%rip)    # 0x7a4648
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_table_scan_16_pointer = parasail_sg_dx_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_16_pointer = parasail_sg_dx_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_16_pointer = parasail_sg_dx_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_16_pointer = parasail_sg_dx_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_16_pointer = parasail_sg_dx_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23261b
leaq 0x2bf1ee(%rip), %rax    # 0x4f1807
jmp 0x23264a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23262f
leaq 0x1cac9f(%rip), %rax    # 0x3fd2cc
jmp 0x23264a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232643
leaq 0x68367(%rip), %rax     # 0x29a9a8
jmp 0x23264a
leaq 0xdcdb4(%rip), %rax     # 0x30f3fe
movq %rax, 0x571fff(%rip)    # 0x7a4650
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_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 0x594f9c
testl %eax, %eax
je 0x2326a4
leaq 0x2c343d(%rip), %rax    # 0x4f5adf
jmp 0x2326d3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2326b8
leaq 0x1cebff(%rip), %rax    # 0x4012b5
jmp 0x2326d3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2326cc
leaq 0x682de(%rip), %rax     # 0x29a9a8
jmp 0x2326d3
leaq 0xe1271(%rip), %rax     # 0x313944
movq %rax, 0x571f7e(%rip)    # 0x7a4658
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x594f9c
testl %eax, %eax
je 0x23272d
leaq 0x2ddf44(%rip), %rax    # 0x51066f
jmp 0x23275c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232741
leaq 0x1e3aa2(%rip), %rax    # 0x4161e1
jmp 0x23275c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232755
leaq 0x673d7(%rip), %rax     # 0x299b2a
jmp 0x23275c
leaq 0xf7e39(%rip), %rax     # 0x32a595
movq %rax, 0x571efd(%rip)    # 0x7a4660
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