LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x22d3a8
leaq 0x2a17cf(%rip), %rax    # 0x4ceb75
jmp 0x22d3d7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d3bc
leaq 0x1b49bd(%rip), %rax    # 0x3e1d77
jmp 0x22d3d7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d3d0
leaq 0x6d5bf(%rip), %rax     # 0x29a98d
jmp 0x22d3d7
leaq 0xc4c82(%rip), %rax     # 0x2f2059
movq %rax, 0x576dba(%rip)    # 0x7a4198
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d431
leaq 0x2b2b1f(%rip), %rax    # 0x4dff4e
jmp 0x22d460
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d445
leaq 0x1c066d(%rip), %rax    # 0x3edab0
jmp 0x22d460
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d459
leaq 0x6c6b8(%rip), %rax     # 0x299b0f
jmp 0x22d460
leaq 0xd19b4(%rip), %rax     # 0x2fee14
movq %rax, 0x576d39(%rip)    # 0x7a41a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d4ba
leaq 0x2b4673(%rip), %rax    # 0x4e1b2b
jmp 0x22d4e9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d4ce
leaq 0x1c1e0a(%rip), %rax    # 0x3ef2d6
jmp 0x22d4e9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d4e2
leaq 0x6c62f(%rip), %rax     # 0x299b0f
jmp 0x22d4e9
leaq 0xd339e(%rip), %rax     # 0x300887
movq %rax, 0x576cb8(%rip)    # 0x7a41a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d543
leaq 0x2b65e1(%rip), %rax    # 0x4e3b22
jmp 0x22d572
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d557
leaq 0x1c36ed(%rip), %rax    # 0x3f0c42
jmp 0x22d572
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d56b
leaq 0x6c5a6(%rip), %rax     # 0x299b0f
jmp 0x22d572
leaq 0xd4d46(%rip), %rax     # 0x3022b8
movq %rax, 0x576c37(%rip)    # 0x7a41b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d5cc
leaq 0x2b8bec(%rip), %rax    # 0x4e61b6
jmp 0x22d5fb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d5e0
leaq 0x1c563c(%rip), %rax    # 0x3f2c1a
jmp 0x22d5fb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d5f4
leaq 0x6c51d(%rip), %rax     # 0x299b0f
jmp 0x22d5fb
leaq 0xd705e(%rip), %rax     # 0x304659
movq %rax, 0x576bb6(%rip)    # 0x7a41b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d655
leaq 0x2a3d64(%rip), %rax    # 0x4d13b7
jmp 0x22d684
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d669
leaq 0x1b661c(%rip), %rax    # 0x3e3c83
jmp 0x22d684
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d67d
leaq 0x6c494(%rip), %rax     # 0x299b0f
jmp 0x22d684
leaq 0xc6ccd(%rip), %rax     # 0x2f4351
movq %rax, 0x576b35(%rip)    # 0x7a41c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d6de
leaq 0x2a649f(%rip), %rax    # 0x4d3b7b
jmp 0x22d70d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d6f2
leaq 0x1b830b(%rip), %rax    # 0x3e59fb
jmp 0x22d70d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d706
leaq 0x6c40b(%rip), %rax     # 0x299b0f
jmp 0x22d70d
leaq 0xc8d4b(%rip), %rax     # 0x2f6458
movq %rax, 0x576ab4(%rip)    # 0x7a41c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d767
leaq 0x2a989a(%rip), %rax    # 0x4d6fff
jmp 0x22d796
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d77b
leaq 0x1ba6c0(%rip), %rax    # 0x3e7e39
jmp 0x22d796
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d78f
leaq 0x6c382(%rip), %rax     # 0x299b0f
jmp 0x22d796
leaq 0xcb3a7(%rip), %rax     # 0x2f8b3d
movq %rax, 0x576a33(%rip)    # 0x7a41d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d7f0
leaq 0x2aed54(%rip), %rax    # 0x4dc542
jmp 0x22d81f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d804
leaq 0x1bda80(%rip), %rax    # 0x3eb282
jmp 0x22d81f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d818
leaq 0x6c2f9(%rip), %rax     # 0x299b0f
jmp 0x22d81f
leaq 0xceba4(%rip), %rax     # 0x2fc3c3
movq %rax, 0x5769b2(%rip)    # 0x7a41d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d879
leaq 0x2bc5c7(%rip), %rax    # 0x4e9e3e
jmp 0x22d8a8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d88d
leaq 0x1c8d84(%rip), %rax    # 0x3f660f
jmp 0x22d8a8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d8a1
leaq 0x6d0ee(%rip), %rax     # 0x29a98d
jmp 0x22d8a8
leaq 0xda452(%rip), %rax     # 0x307cfa
movq %rax, 0x576931(%rip)    # 0x7a41e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d902
leaq 0x2c009a(%rip), %rax    # 0x4ed99a
jmp 0x22d931
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d916
leaq 0x1cc21b(%rip), %rax    # 0x3f9b2f
jmp 0x22d931
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d92a
leaq 0x6d065(%rip), %rax     # 0x29a98d
jmp 0x22d931
leaq 0xdded3(%rip), %rax     # 0x30b804
movq %rax, 0x5768b0(%rip)    # 0x7a41e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22d98b
leaq 0x2c3e63(%rip), %rax    # 0x4f17ec
jmp 0x22d9ba
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22d99f
leaq 0x1cf914(%rip), %rax    # 0x3fd2b1
jmp 0x22d9ba
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22d9b3
leaq 0x6cfdc(%rip), %rax     # 0x29a98d
jmp 0x22d9ba
leaq 0xe1a29(%rip), %rax     # 0x30f3e3
movq %rax, 0x57682f(%rip)    # 0x7a41f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22da14
leaq 0x2c80b2(%rip), %rax    # 0x4f5ac4
jmp 0x22da43
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22da28
leaq 0x1d3874(%rip), %rax    # 0x40129a
jmp 0x22da43
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22da3c
leaq 0x6cf53(%rip), %rax     # 0x29a98d
jmp 0x22da43
leaq 0xe5ee6(%rip), %rax     # 0x313929
movq %rax, 0x5767ae(%rip)    # 0x7a41f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22da9d
leaq 0x2e2bb9(%rip), %rax    # 0x510654
jmp 0x22dacc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22dab1
leaq 0x1e8717(%rip), %rax    # 0x4161c6
jmp 0x22dacc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22dac5
leaq 0x6c04c(%rip), %rax     # 0x299b0f
jmp 0x22dacc
leaq 0xfcaae(%rip), %rax     # 0x32a57a
movq %rax, 0x57672d(%rip)    # 0x7a4200
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22db26
leaq 0x2e6463(%rip), %rax    # 0x513f87
jmp 0x22db55
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22db3a
leaq 0x1eb9ba(%rip), %rax    # 0x4194f2
jmp 0x22db55
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22db4e
leaq 0x6bfc3(%rip), %rax     # 0x299b0f
jmp 0x22db55
leaq 0x100410(%rip), %rax    # 0x32df65
movq %rax, 0x5766ac(%rip)    # 0x7a4208
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22dbaf
leaq 0x2eab11(%rip), %rax    # 0x5186be
jmp 0x22dbde
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22dbc3
leaq 0x1ef320(%rip), %rax    # 0x41cee1
jmp 0x22dbde
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22dbd7
leaq 0x6bf3a(%rip), %rax     # 0x299b0f
jmp 0x22dbde
leaq 0x10409c(%rip), %rax    # 0x331c7a
movq %rax, 0x57662b(%rip)    # 0x7a4210
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22dc38
leaq 0x2ef582(%rip), %rax    # 0x51d1b8
jmp 0x22dc67
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22dc4c
leaq 0x1f400b(%rip), %rax    # 0x421c55
jmp 0x22dc67
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22dc60
leaq 0x6beb1(%rip), %rax     # 0x299b0f
jmp 0x22dc67
leaq 0x109152(%rip), %rax    # 0x336db9
movq %rax, 0x5765aa(%rip)    # 0x7a4218
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22dcc1
leaq 0x2cc48a(%rip), %rax    # 0x4fa149
jmp 0x22dcf0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22dcd5
leaq 0x1d737d(%rip), %rax    # 0x405050
jmp 0x22dcf0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22dce9
leaq 0x6be28(%rip), %rax     # 0x299b0f
jmp 0x22dcf0
leaq 0xea0d6(%rip), %rax     # 0x317dc6
movq %rax, 0x576529(%rip)    # 0x7a4220
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22dd4a
leaq 0x2d0ee9(%rip), %rax    # 0x4fec31
jmp 0x22dd79
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22dd5e
leaq 0x1dae3e(%rip), %rax    # 0x408b9a
jmp 0x22dd79
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22dd72
leaq 0x6bd9f(%rip), %rax     # 0x299b0f
jmp 0x22dd79
leaq 0xee1ca(%rip), %rax     # 0x31bf43
movq %rax, 0x5764a8(%rip)    # 0x7a4228
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22ddd3
leaq 0x2d6267(%rip), %rax    # 0x504038
jmp 0x22de02
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22dde7
leaq 0x1defec(%rip), %rax    # 0x40cdd1
jmp 0x22de02
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ddfb
leaq 0x6bd16(%rip), %rax     # 0x299b0f
jmp 0x22de02
leaq 0xf267b(%rip), %rax     # 0x32047d
movq %rax, 0x576427(%rip)    # 0x7a4230
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22de5c
leaq 0x2dd3fd(%rip), %rax    # 0x50b257
jmp 0x22de8b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22de70
leaq 0x1e4170(%rip), %rax    # 0x411fde
jmp 0x22de8b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22de84
leaq 0x6bc8d(%rip), %rax     # 0x299b0f
jmp 0x22de8b
leaq 0xf7ec1(%rip), %rax     # 0x325d4c
movq %rax, 0x5763a6(%rip)    # 0x7a4238
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22dee5
leaq 0x2f2668(%rip), %rax    # 0x52054b
jmp 0x22df14
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22def9
leaq 0x1f6e0d(%rip), %rax    # 0x424d04
jmp 0x22df14
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22df0d
leaq 0x6ca82(%rip), %rax     # 0x29a98d
jmp 0x22df14
leaq 0x10c358(%rip), %rax    # 0x33a26c
movq %rax, 0x576325(%rip)    # 0x7a4240
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