LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_table_scan_32_dispatcher
parasail_result_t* parasail_sg_de_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1cfeea
leaq 0x2cb83b(%rip), %rax    # 0x49b723
jmp 0x1cff19
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cfefe
leaq 0x1d3713(%rip), %rax    # 0x3a360f
jmp 0x1cff19
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cff12
leaq 0x6da0f(%rip), %rax     # 0x23d91f
jmp 0x1cff19
leaq 0xccc50(%rip), %rax     # 0x29cb69
movq %rax, 0x56d268(%rip)    # 0x73d188
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_de_dispatch.c
// Function: parasail_sg_de_table_scan_16_dispatcher
parasail_result_t* parasail_sg_de_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1cff73
leaq 0x2cd9a2(%rip), %rax    # 0x49d913
jmp 0x1cffa2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1cff87
leaq 0x1d5549(%rip), %rax    # 0x3a54ce
jmp 0x1cffa2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1cff9b
leaq 0x6d986(%rip), %rax     # 0x23d91f
jmp 0x1cffa2
leaq 0xcebcf(%rip), %rax     # 0x29eb71
movq %rax, 0x56d1e7(%rip)    # 0x73d190
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_de_dispatch.c
// Function: parasail_sg_de_table_scan_8_dispatcher
parasail_result_t* parasail_sg_de_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1cfffc
leaq 0x2cffac(%rip), %rax    # 0x49ffa6
jmp 0x1d002b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0010
leaq 0x1d7634(%rip), %rax    # 0x3a7642
jmp 0x1d002b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0024
leaq 0x6d8fd(%rip), %rax     # 0x23d91f
jmp 0x1d002b
leaq 0xd10ee(%rip), %rax     # 0x2a1119
movq %rax, 0x56d166(%rip)    # 0x73d198
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_64_dispatcher
parasail_result_t* parasail_sg_de_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0085
leaq 0x2e16d1(%rip), %rax    # 0x4b1754
jmp 0x1d00b4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0099
leaq 0x1e3f36(%rip), %rax    # 0x3b3fcd
jmp 0x1d00b4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d00ad
leaq 0x6c806(%rip), %rax     # 0x23c8b1
jmp 0x1d00b4
leaq 0xdf6f2(%rip), %rax     # 0x2af7a6
movq %rax, 0x56d0e5(%rip)    # 0x73d1a0
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_32_dispatcher
parasail_result_t* parasail_sg_de_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d010e
leaq 0x2e374f(%rip), %rax    # 0x4b385b
jmp 0x1d013d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0122
leaq 0x1e5e2b(%rip), %rax    # 0x3b5f4b
jmp 0x1d013d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0136
leaq 0x6c77d(%rip), %rax     # 0x23c8b1
jmp 0x1d013d
leaq 0xe1999(%rip), %rax     # 0x2b1ad6
movq %rax, 0x56d064(%rip)    # 0x73d1a8
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_16_dispatcher
parasail_result_t* parasail_sg_de_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0197
leaq 0x2e5a6d(%rip), %rax    # 0x4b5c02
jmp 0x1d01c6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d01ab
leaq 0x1e7e35(%rip), %rax    # 0x3b7fde
jmp 0x1d01c6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d01bf
leaq 0x6c6f4(%rip), %rax     # 0x23c8b1
jmp 0x1d01c6
leaq 0xe3aa1(%rip), %rax     # 0x2b3c67
movq %rax, 0x56cfe3(%rip)    # 0x73d1b0
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_8_dispatcher
parasail_result_t* parasail_sg_de_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0220
leaq 0x2e8371(%rip), %rax    # 0x4b858f
jmp 0x1d024f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0234
leaq 0x1ea11a(%rip), %rax    # 0x3ba34c
jmp 0x1d024f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0248
leaq 0x6c66b(%rip), %rax     # 0x23c8b1
jmp 0x1d024f
leaq 0xe5f77(%rip), %rax     # 0x2b61c6
movq %rax, 0x56cf62(%rip)    # 0x73d1b8
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_de_dispatch.c
// Function: parasail_sg_de_table_diag_64_dispatcher
parasail_result_t* parasail_sg_de_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d02a9
leaq 0x2d2453(%rip), %rax    # 0x4a26fa
jmp 0x1d02d8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d02bd
leaq 0x1d94d9(%rip), %rax    # 0x3a9794
jmp 0x1d02d8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d02d1
leaq 0x6c5e2(%rip), %rax     # 0x23c8b1
jmp 0x1d02d8
leaq 0xd3776(%rip), %rax     # 0x2a3a4e
movq %rax, 0x56cee1(%rip)    # 0x73d1c0
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_de_dispatch.c
// Function: parasail_sg_de_table_diag_32_dispatcher
parasail_result_t* parasail_sg_de_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0332
leaq 0x2d4c1e(%rip), %rax    # 0x4a4f4e
jmp 0x1d0361
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0346
leaq 0x1db37c(%rip), %rax    # 0x3ab6c0
jmp 0x1d0361
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d035a
leaq 0x6c559(%rip), %rax     # 0x23c8b1
jmp 0x1d0361
leaq 0xd5a3b(%rip), %rax     # 0x2a5d9c
movq %rax, 0x56ce60(%rip)    # 0x73d1c8
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_de_dispatch.c
// Function: parasail_sg_de_table_diag_16_dispatcher
parasail_result_t* parasail_sg_de_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d03bb
leaq 0x2d837c(%rip), %rax    # 0x4a8735
jmp 0x1d03ea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d03cf
leaq 0x1dd935(%rip), %rax    # 0x3add02
jmp 0x1d03ea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d03e3
leaq 0x6c4d0(%rip), %rax     # 0x23c8b1
jmp 0x1d03ea
leaq 0xd836c(%rip), %rax     # 0x2a8756
movq %rax, 0x56cddf(%rip)    # 0x73d1d0
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_de_dispatch.c
// Function: parasail_sg_de_table_diag_8_dispatcher
parasail_result_t* parasail_sg_de_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0444
leaq 0x2ddb88(%rip), %rax    # 0x4adfca
jmp 0x1d0473
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0458
leaq 0x1e1068(%rip), %rax    # 0x3b14be
jmp 0x1d0473
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d046c
leaq 0x6c447(%rip), %rax     # 0x23c8b1
jmp 0x1d0473
leaq 0xdc124(%rip), %rax     # 0x2ac597
movq %rax, 0x56cd5e(%rip)    # 0x73d1d8
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_de_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d04cd
leaq 0x2ebf98(%rip), %rax    # 0x4bc463
jmp 0x1d04fc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d04e1
leaq 0x1ee036(%rip), %rax    # 0x3be515
jmp 0x1d04fc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d04f5
leaq 0x6d42c(%rip), %rax     # 0x23d91f
jmp 0x1d04fc
leaq 0xea01e(%rip), %rax     # 0x2ba51a
movq %rax, 0x56ccdd(%rip)    # 0x73d1e0
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_de_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0556
leaq 0x2efd8e(%rip), %rax    # 0x4c02e2
jmp 0x1d0585
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d056a
leaq 0x1f1b1e(%rip), %rax    # 0x3c2086
jmp 0x1d0585
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d057e
leaq 0x6d3a3(%rip), %rax     # 0x23d91f
jmp 0x1d0585
leaq 0xee498(%rip), %rax     # 0x2bea1d
movq %rax, 0x56cc5c(%rip)    # 0x73d1e8
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_table_scan_16_pointer = parasail_sg_de_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_scan_16_pointer = parasail_sg_de_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_scan_16_pointer = parasail_sg_de_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_scan_16_pointer = parasail_sg_de_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_scan_16_pointer = parasail_sg_de_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x1d05df
leaq 0x2f3afd(%rip), %rax    # 0x4c40da
jmp 0x1d060e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d05f3
leaq 0x1f554c(%rip), %rax    # 0x3c5b3d
jmp 0x1d060e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0607
leaq 0x6d31a(%rip), %rax     # 0x23d91f
jmp 0x1d060e
leaq 0xf2388(%rip), %rax     # 0x2c2996
movq %rax, 0x56cbdb(%rip)    # 0x73d1f0
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_table_scan_8_pointer = parasail_sg_de_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_scan_8_pointer = parasail_sg_de_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_scan_8_pointer = parasail_sg_de_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_scan_8_pointer = parasail_sg_de_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_scan_8_pointer = parasail_sg_de_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x5672cf
testl %eax, %eax
je 0x1d0668
leaq 0x2f7e03(%rip), %rax    # 0x4c8469
jmp 0x1d0697
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d067c
leaq 0x1f927a(%rip), %rax    # 0x3c98f4
jmp 0x1d0697
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0690
leaq 0x6d291(%rip), %rax     # 0x23d91f
jmp 0x1d0697
leaq 0xf65a7(%rip), %rax     # 0x2c6c3e
movq %rax, 0x56cb5a(%rip)    # 0x73d1f8
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_table_striped_64_pointer = parasail_sg_de_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_striped_64_pointer = parasail_sg_de_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_striped_64_pointer = parasail_sg_de_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_striped_64_pointer = parasail_sg_de_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_striped_64_pointer = parasail_sg_de_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x5672cf
testl %eax, %eax
je 0x1d06f1
leaq 0x3110f2(%rip), %rax    # 0x4e17e1
jmp 0x1d0720
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0705
leaq 0x20e723(%rip), %rax    # 0x3dee26
jmp 0x1d0720
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0719
leaq 0x6c19a(%rip), %rax     # 0x23c8b1
jmp 0x1d0720
leaq 0x10e866(%rip), %rax    # 0x2def86
movq %rax, 0x56cad9(%rip)    # 0x73d200
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_de_stats_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_striped_32_pointer = parasail_sg_de_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_striped_32_pointer = parasail_sg_de_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_striped_32_pointer = parasail_sg_de_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_striped_32_pointer = parasail_sg_de_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_striped_32_pointer = parasail_sg_de_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x1d077a
leaq 0x314fd1(%rip), %rax    # 0x4e5749
jmp 0x1d07a9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d078e
leaq 0x21239e(%rip), %rax    # 0x3e2b2a
jmp 0x1d07a9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d07a2
leaq 0x6c111(%rip), %rax     # 0x23c8b1
jmp 0x1d07a9
leaq 0x112d97(%rip), %rax    # 0x2e3540
movq %rax, 0x56ca58(%rip)    # 0x73d208
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_de_stats_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_striped_16_pointer = parasail_sg_de_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_striped_16_pointer = parasail_sg_de_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_striped_16_pointer = parasail_sg_de_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_striped_16_pointer = parasail_sg_de_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_striped_16_pointer = parasail_sg_de_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x1d0803
leaq 0x319080(%rip), %rax    # 0x4e9881
jmp 0x1d0832
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0817
leaq 0x21617d(%rip), %rax    # 0x3e6992
jmp 0x1d0832
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d082b
leaq 0x6c088(%rip), %rax     # 0x23c8b1
jmp 0x1d0832
leaq 0x116ed9(%rip), %rax    # 0x2e770b
movq %rax, 0x56c9d7(%rip)    # 0x73d210
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_de_stats_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_striped_8_pointer = parasail_sg_de_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_striped_8_pointer = parasail_sg_de_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_striped_8_pointer = parasail_sg_de_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_striped_8_pointer = parasail_sg_de_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_striped_8_pointer = parasail_sg_de_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x1d088c
leaq 0x31d790(%rip), %rax    # 0x4ee01a
jmp 0x1d08bb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d08a0
leaq 0x21a2a7(%rip), %rax    # 0x3eab45
jmp 0x1d08bb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d08b4
leaq 0x6bfff(%rip), %rax     # 0x23c8b1
jmp 0x1d08bb
leaq 0x11b42b(%rip), %rax    # 0x2ebce6
movq %rax, 0x56c956(%rip)    # 0x73d218
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_de_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_diag_64_pointer = parasail_sg_de_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_diag_64_pointer = parasail_sg_de_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_diag_64_pointer = parasail_sg_de_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_diag_64_pointer = parasail_sg_de_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_diag_64_pointer = parasail_sg_de_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x1d0915
leaq 0x2fbefc(%rip), %rax    # 0x4cc80f
jmp 0x1d0944
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0929
leaq 0x1fd021(%rip), %rax    # 0x3cd948
jmp 0x1d0944
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d093d
leaq 0x6bf76(%rip), %rax     # 0x23c8b1
jmp 0x1d0944
leaq 0xfacdf(%rip), %rax     # 0x2cb623
movq %rax, 0x56c8d5(%rip)    # 0x73d220
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_de_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_diag_32_pointer = parasail_sg_de_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_diag_32_pointer = parasail_sg_de_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_diag_32_pointer = parasail_sg_de_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_diag_32_pointer = parasail_sg_de_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_diag_32_pointer = parasail_sg_de_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x1d099e
leaq 0x2fff26(%rip), %rax    # 0x4d08c2
jmp 0x1d09cd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d09b2
leaq 0x200b0e(%rip), %rax    # 0x3d14be
jmp 0x1d09cd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d09c6
leaq 0x6beed(%rip), %rax     # 0x23c8b1
jmp 0x1d09cd
leaq 0xff000(%rip), %rax     # 0x2cf9cd
movq %rax, 0x56c854(%rip)    # 0x73d228
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_de_dispatch.c
// Function: parasail_sg_de_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_de_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_diag_16_pointer = parasail_sg_de_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_diag_16_pointer = parasail_sg_de_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_diag_16_pointer = parasail_sg_de_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_diag_16_pointer = parasail_sg_de_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_diag_16_pointer = parasail_sg_de_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_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 0x1d0a27
leaq 0x304f30(%rip), %rax    # 0x4d5955
jmp 0x1d0a56
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0a3b
leaq 0x204ba1(%rip), %rax    # 0x3d55da
jmp 0x1d0a56
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0a4f
leaq 0x6be64(%rip), %rax     # 0x23c8b1
jmp 0x1d0a56
leaq 0x103501(%rip), %rax    # 0x2d3f57
movq %rax, 0x56c7d3(%rip)    # 0x73d230
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