LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4732
leaq 0x2bacdb(%rip), %rax    # 0x48f40b
jmp 0x1d4761
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4746
leaq 0x1c4590(%rip), %rax    # 0x398cd4
jmp 0x1d4761
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d475a
leaq 0x68175(%rip), %rax     # 0x23c8cd
jmp 0x1d4761
leaq 0xbb198(%rip), %rax     # 0x28f8f9
movq %rax, 0x568e40(%rip)    # 0x73d5a8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d47bb
leaq 0x2bdd8d(%rip), %rax    # 0x492546
jmp 0x1d47ea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d47cf
leaq 0x1c7793(%rip), %rax    # 0x39bf60
jmp 0x1d47ea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d47e3
leaq 0x680ec(%rip), %rax     # 0x23c8cd
jmp 0x1d47ea
leaq 0xbe70b(%rip), %rax     # 0x292ef5
movq %rax, 0x568dbf(%rip)    # 0x73d5b0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4844
leaq 0x2c0f31(%rip), %rax    # 0x495773
jmp 0x1d4873
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4858
leaq 0x1ca9e2(%rip), %rax    # 0x39f238
jmp 0x1d4873
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d486c
leaq 0x68063(%rip), %rax     # 0x23c8cd
jmp 0x1d4873
leaq 0xc1ec4(%rip), %rax     # 0x296737
movq %rax, 0x568d3e(%rip)    # 0x73d5b8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d48cd
leaq 0x2a7083(%rip), %rax    # 0x47b94e
jmp 0x1d48fc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d48e1
leaq 0x1b2582(%rip), %rax    # 0x386e61
jmp 0x1d48fc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d48f5
leaq 0x67fda(%rip), %rax     # 0x23c8cd
jmp 0x1d48fc
leaq 0xa641d(%rip), %rax     # 0x27ad19
movq %rax, 0x568cbd(%rip)    # 0x73d5c0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4956
leaq 0x2aa743(%rip), %rax    # 0x47f097
jmp 0x1d4985
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d496a
leaq 0x1b5a73(%rip), %rax    # 0x38a3db
jmp 0x1d4985
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d497e
leaq 0x67f51(%rip), %rax     # 0x23c8cd
jmp 0x1d4985
leaq 0xaa08a(%rip), %rax     # 0x27ea0f
movq %rax, 0x568c3c(%rip)    # 0x73d5c8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d49df
leaq 0x2ae61f(%rip), %rax    # 0x482ffc
jmp 0x1d4a0e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d49f3
leaq 0x1b90d9(%rip), %rax    # 0x38daca
jmp 0x1d4a0e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4a07
leaq 0x67ec8(%rip), %rax     # 0x23c8cd
jmp 0x1d4a0e
leaq 0xada8d(%rip), %rax     # 0x28249b
movq %rax, 0x568bbb(%rip)    # 0x73d5d0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4a68
leaq 0x2b33c2(%rip), %rax    # 0x487e28
jmp 0x1d4a97
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4a7c
leaq 0x1bd012(%rip), %rax    # 0x391a8c
jmp 0x1d4a97
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4a90
leaq 0x67e3f(%rip), %rax     # 0x23c8cd
jmp 0x1d4a97
leaq 0xb25b4(%rip), %rax     # 0x28704b
movq %rax, 0x568b3a(%rip)    # 0x73d5d8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4af1
leaq 0x2c4cc9(%rip), %rax    # 0x4997b8
jmp 0x1d4b20
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4b05
leaq 0x1cce55(%rip), %rax    # 0x3a1958
jmp 0x1d4b20
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4b19
leaq 0x68e24(%rip), %rax     # 0x23d93b
jmp 0x1d4b20
leaq 0xc5edc(%rip), %rax     # 0x29a9fc
movq %rax, 0x568ab9(%rip)    # 0x73d5e0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4b7a
leaq 0x2c6bc7(%rip), %rax    # 0x49b73f
jmp 0x1d4ba9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4b8e
leaq 0x1cea9f(%rip), %rax    # 0x3a362b
jmp 0x1d4ba9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4ba2
leaq 0x68d9b(%rip), %rax     # 0x23d93b
jmp 0x1d4ba9
leaq 0xc7fdc(%rip), %rax     # 0x29cb85
movq %rax, 0x568a38(%rip)    # 0x73d5e8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4c03
leaq 0x2c8d2e(%rip), %rax    # 0x49d92f
jmp 0x1d4c32
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4c17
leaq 0x1d08d5(%rip), %rax    # 0x3a54ea
jmp 0x1d4c32
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4c2b
leaq 0x68d12(%rip), %rax     # 0x23d93b
jmp 0x1d4c32
leaq 0xc9f5b(%rip), %rax     # 0x29eb8d
movq %rax, 0x5689b7(%rip)    # 0x73d5f0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4c8c
leaq 0x2cb338(%rip), %rax    # 0x49ffc2
jmp 0x1d4cbb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4ca0
leaq 0x1d29c0(%rip), %rax    # 0x3a765e
jmp 0x1d4cbb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4cb4
leaq 0x68c89(%rip), %rax     # 0x23d93b
jmp 0x1d4cbb
leaq 0xcc47a(%rip), %rax     # 0x2a1135
movq %rax, 0x568936(%rip)    # 0x73d5f8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4d15
leaq 0x2dca5d(%rip), %rax    # 0x4b1770
jmp 0x1d4d44
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4d29
leaq 0x1df2c2(%rip), %rax    # 0x3b3fe9
jmp 0x1d4d44
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4d3d
leaq 0x67b92(%rip), %rax     # 0x23c8cd
jmp 0x1d4d44
leaq 0xdaa7e(%rip), %rax     # 0x2af7c2
movq %rax, 0x5688b5(%rip)    # 0x73d600
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4d9e
leaq 0x2deadb(%rip), %rax    # 0x4b3877
jmp 0x1d4dcd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4db2
leaq 0x1e11b7(%rip), %rax    # 0x3b5f67
jmp 0x1d4dcd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4dc6
leaq 0x67b09(%rip), %rax     # 0x23c8cd
jmp 0x1d4dcd
leaq 0xdcd25(%rip), %rax     # 0x2b1af2
movq %rax, 0x568834(%rip)    # 0x73d608
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4e27
leaq 0x2e0df9(%rip), %rax    # 0x4b5c1e
jmp 0x1d4e56
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4e3b
leaq 0x1e31c1(%rip), %rax    # 0x3b7ffa
jmp 0x1d4e56
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4e4f
leaq 0x67a80(%rip), %rax     # 0x23c8cd
jmp 0x1d4e56
leaq 0xdee2d(%rip), %rax     # 0x2b3c83
movq %rax, 0x5687b3(%rip)    # 0x73d610
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4eb0
leaq 0x2e36fd(%rip), %rax    # 0x4b85ab
jmp 0x1d4edf
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4ec4
leaq 0x1e54a6(%rip), %rax    # 0x3ba368
jmp 0x1d4edf
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4ed8
leaq 0x679f7(%rip), %rax     # 0x23c8cd
jmp 0x1d4edf
leaq 0xe1303(%rip), %rax     # 0x2b61e2
movq %rax, 0x568732(%rip)    # 0x73d618
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4f39
leaq 0x2cd7df(%rip), %rax    # 0x4a2716
jmp 0x1d4f68
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4f4d
leaq 0x1d4865(%rip), %rax    # 0x3a97b0
jmp 0x1d4f68
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4f61
leaq 0x6796e(%rip), %rax     # 0x23c8cd
jmp 0x1d4f68
leaq 0xceb02(%rip), %rax     # 0x2a3a6a
movq %rax, 0x5686b1(%rip)    # 0x73d620
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d4fc2
leaq 0x2cffaa(%rip), %rax    # 0x4a4f6a
jmp 0x1d4ff1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4fd6
leaq 0x1d6708(%rip), %rax    # 0x3ab6dc
jmp 0x1d4ff1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4fea
leaq 0x678e5(%rip), %rax     # 0x23c8cd
jmp 0x1d4ff1
leaq 0xd0dc7(%rip), %rax     # 0x2a5db8
movq %rax, 0x568630(%rip)    # 0x73d628
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d504b
leaq 0x2d3708(%rip), %rax    # 0x4a8751
jmp 0x1d507a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d505f
leaq 0x1d8cc1(%rip), %rax    # 0x3add1e
jmp 0x1d507a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5073
leaq 0x6785c(%rip), %rax     # 0x23c8cd
jmp 0x1d507a
leaq 0xd36f8(%rip), %rax     # 0x2a8772
movq %rax, 0x5685af(%rip)    # 0x73d630
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d50d4
leaq 0x2d8f14(%rip), %rax    # 0x4adfe6
jmp 0x1d5103
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d50e8
leaq 0x1dc3f4(%rip), %rax    # 0x3b14da
jmp 0x1d5103
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d50fc
leaq 0x677d3(%rip), %rax     # 0x23c8cd
jmp 0x1d5103
leaq 0xd74b0(%rip), %rax     # 0x2ac5b3
movq %rax, 0x56852e(%rip)    # 0x73d638
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d515d
leaq 0x2e7324(%rip), %rax    # 0x4bc47f
jmp 0x1d518c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5171
leaq 0x1e93c2(%rip), %rax    # 0x3be531
jmp 0x1d518c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5185
leaq 0x687b8(%rip), %rax     # 0x23d93b
jmp 0x1d518c
leaq 0xe53aa(%rip), %rax     # 0x2ba536
movq %rax, 0x5684ad(%rip)    # 0x73d640
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d51e6
leaq 0x2eb11a(%rip), %rax    # 0x4c02fe
jmp 0x1d5215
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d51fa
leaq 0x1eceaa(%rip), %rax    # 0x3c20a2
jmp 0x1d5215
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d520e
leaq 0x6872f(%rip), %rax     # 0x23d93b
jmp 0x1d5215
leaq 0xe9824(%rip), %rax     # 0x2bea39
movq %rax, 0x56842c(%rip)    # 0x73d648
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1d526f
leaq 0x2eee89(%rip), %rax    # 0x4c40f6
jmp 0x1d529e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5283
leaq 0x1f08d8(%rip), %rax    # 0x3c5b59
jmp 0x1d529e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5297
leaq 0x686a6(%rip), %rax     # 0x23d93b
jmp 0x1d529e
leaq 0xed714(%rip), %rax     # 0x2c29b2
movq %rax, 0x5683ab(%rip)    # 0x73d650
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