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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_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 0x22df6e
leaq 0x2f4478(%rip), %rax    # 0x5223e4
jmp 0x22df9d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22df82
leaq 0x1f87b3(%rip), %rax    # 0x426733
jmp 0x22df9d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22df96
leaq 0x6c9f9(%rip), %rax     # 0x29a98d
jmp 0x22df9d
leaq 0x10df74(%rip), %rax    # 0x33bf11
movq %rax, 0x5762a4(%rip)    # 0x7a4248
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_16_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_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 0x22dff7
leaq 0x2f60c5(%rip), %rax    # 0x5240ba
jmp 0x22e026
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e00b
leaq 0x1fa0f3(%rip), %rax    # 0x4280fc
jmp 0x22e026
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e01f
leaq 0x6c970(%rip), %rax     # 0x29a98d
jmp 0x22e026
leaq 0x10f9d4(%rip), %rax    # 0x33d9fa
movq %rax, 0x576223(%rip)    # 0x7a4250
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_8_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_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 0x22e080
leaq 0x2f82fc(%rip), %rax    # 0x52637a
jmp 0x22e0af
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e094
leaq 0x1fbd10(%rip), %rax    # 0x429da2
jmp 0x22e0af
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e0a8
leaq 0x6c8e7(%rip), %rax     # 0x29a98d
jmp 0x22e0af
leaq 0x111842(%rip), %rax    # 0x33f8f1
movq %rax, 0x5761a2(%rip)    # 0x7a4258
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_striped_64_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e109
leaq 0x30a7b4(%rip), %rax    # 0x5388bb
jmp 0x22e138
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e11d
leaq 0x208143(%rip), %rax    # 0x43625e
jmp 0x22e138
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e131
leaq 0x6b9e0(%rip), %rax     # 0x299b0f
jmp 0x22e138
leaq 0x11ead3(%rip), %rax    # 0x34cc0b
movq %rax, 0x576121(%rip)    # 0x7a4260
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_striped_32_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e192
leaq 0x30c230(%rip), %rax    # 0x53a3c0
jmp 0x22e1c1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e1a6
leaq 0x20996e(%rip), %rax    # 0x437b12
jmp 0x22e1c1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e1ba
leaq 0x6b957(%rip), %rax     # 0x299b0f
jmp 0x22e1c1
leaq 0x120463(%rip), %rax    # 0x34e624
movq %rax, 0x5760a0(%rip)    # 0x7a4268
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_striped_16_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e21b
leaq 0x30dc44(%rip), %rax    # 0x53be5d
jmp 0x22e24a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e22f
leaq 0x20b0ca(%rip), %rax    # 0x4392f7
jmp 0x22e24a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e243
leaq 0x6b8ce(%rip), %rax     # 0x299b0f
jmp 0x22e24a
leaq 0x121c85(%rip), %rax    # 0x34fecf
movq %rax, 0x57601f(%rip)    # 0x7a4270
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_striped_8_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e2a4
leaq 0x30fc9b(%rip), %rax    # 0x53df3d
jmp 0x22e2d3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e2b8
leaq 0x20cb20(%rip), %rax    # 0x43add6
jmp 0x22e2d3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e2cc
leaq 0x6b845(%rip), %rax     # 0x299b0f
jmp 0x22e2d3
leaq 0x123914(%rip), %rax    # 0x351be7
movq %rax, 0x575f9e(%rip)    # 0x7a4278
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_diag_64_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e32d
leaq 0x2fa935(%rip), %rax    # 0x528c60
jmp 0x22e35c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e341
leaq 0x1fda17(%rip), %rax    # 0x42bd56
jmp 0x22e35c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e355
leaq 0x6b7bc(%rip), %rax     # 0x299b0f
jmp 0x22e35c
leaq 0x11386d(%rip), %rax    # 0x341bc9
movq %rax, 0x575f1d(%rip)    # 0x7a4280
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_diag_32_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e3b6
leaq 0x2fd12f(%rip), %rax    # 0x52b4e3
jmp 0x22e3e5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e3ca
leaq 0x1ff75f(%rip), %rax    # 0x42db27
jmp 0x22e3e5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e3de
leaq 0x6b733(%rip), %rax     # 0x299b0f
jmp 0x22e3e5
leaq 0x115967(%rip), %rax    # 0x343d4c
movq %rax, 0x575e9c(%rip)    # 0x7a4288
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_diag_16_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e43f
leaq 0x30090b(%rip), %rax    # 0x52ed48
jmp 0x22e46e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e453
leaq 0x201c36(%rip), %rax    # 0x430087
jmp 0x22e46e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e467
leaq 0x6b6aa(%rip), %rax     # 0x299b0f
jmp 0x22e46e
leaq 0x118067(%rip), %rax    # 0x3464d5
movq %rax, 0x575e1b(%rip)    # 0x7a4290
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_diag_8_dispatcher
parasail_result_t* parasail_sg_de_rowcol_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_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_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 0x22e4c8
leaq 0x3066c2(%rip), %rax    # 0x534b88
jmp 0x22e4f7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e4dc
leaq 0x205491(%rip), %rax    # 0x43396b
jmp 0x22e4f7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e4f0
leaq 0x6b621(%rip), %rax     # 0x299b0f
jmp 0x22e4f7
leaq 0x11bb91(%rip), %rax    # 0x34a088
movq %rax, 0x575d9a(%rip)    # 0x7a4298
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_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_de_stats_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_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_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 0x22e551
leaq 0x313637(%rip), %rax    # 0x541b86
jmp 0x22e580
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e565
leaq 0x210174(%rip), %rax    # 0x43e6d7
jmp 0x22e580
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e579
leaq 0x6c416(%rip), %rax     # 0x29a98d
jmp 0x22e580
leaq 0x126c85(%rip), %rax    # 0x355205
movq %rax, 0x575d19(%rip)    # 0x7a42a0
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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e5da
leaq 0x317245(%rip), %rax    # 0x54581d
jmp 0x22e609
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e5ee
leaq 0x21375d(%rip), %rax    # 0x441d49
jmp 0x22e609
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e602
leaq 0x6c38d(%rip), %rax     # 0x29a98d
jmp 0x22e609
leaq 0x12a911(%rip), %rax    # 0x358f1a
movq %rax, 0x575c98(%rip)    # 0x7a42a8
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_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e663
leaq 0x31b266(%rip), %rax    # 0x5498c7
jmp 0x22e692
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e677
leaq 0x216edf(%rip), %rax    # 0x445554
jmp 0x22e692
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e68b
leaq 0x6c304(%rip), %rax     # 0x29a98d
jmp 0x22e692
leaq 0x12e50d(%rip), %rax    # 0x35cb9f
movq %rax, 0x575c17(%rip)    # 0x7a42b0
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_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e6ec
leaq 0x31f2d8(%rip), %rax    # 0x54d9c2
jmp 0x22e71b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e700
leaq 0x21af2d(%rip), %rax    # 0x44962b
jmp 0x22e71b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e714
leaq 0x6c27b(%rip), %rax     # 0x29a98d
jmp 0x22e71b
leaq 0x132b0e(%rip), %rax    # 0x361229
movq %rax, 0x575b96(%rip)    # 0x7a42b8
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_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e775
leaq 0x339b9e(%rip), %rax    # 0x568311
jmp 0x22e7a4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e789
leaq 0x23069b(%rip), %rax    # 0x45ee22
jmp 0x22e7a4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e79d
leaq 0x6b374(%rip), %rax     # 0x299b0f
jmp 0x22e7a4
leaq 0x149ddf(%rip), %rax    # 0x378583
movq %rax, 0x575b15(%rip)    # 0x7a42c0
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_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e7fe
leaq 0x33d310(%rip), %rax    # 0x56bb0c
jmp 0x22e82d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e812
leaq 0x233906(%rip), %rax    # 0x462116
jmp 0x22e82d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e826
leaq 0x6b2eb(%rip), %rax     # 0x299b0f
jmp 0x22e82d
leaq 0x14d71d(%rip), %rax    # 0x37bf4a
movq %rax, 0x575a94(%rip)    # 0x7a42c8
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_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e887
leaq 0x340e36(%rip), %rax    # 0x56f6bb
jmp 0x22e8b6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e89b
leaq 0x236cea(%rip), %rax    # 0x465583
jmp 0x22e8b6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e8af
leaq 0x6b262(%rip), %rax     # 0x299b0f
jmp 0x22e8b6
leaq 0x150f57(%rip), %rax    # 0x37f80d
movq %rax, 0x575a13(%rip)    # 0x7a42d0
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_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e910
leaq 0x344c46(%rip), %rax    # 0x573554
jmp 0x22e93f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e924
leaq 0x23ab0c(%rip), %rax    # 0x46942e
jmp 0x22e93f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e938
leaq 0x6b1d9(%rip), %rax     # 0x299b0f
jmp 0x22e93f
leaq 0x1551d9(%rip), %rax    # 0x383b18
movq %rax, 0x575992(%rip)    # 0x7a42d8
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_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x22e999
leaq 0x323806(%rip), %rax    # 0x55219d
jmp 0x22e9c8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22e9ad
leaq 0x21ebfb(%rip), %rax    # 0x44d5a6
jmp 0x22e9c8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22e9c1
leaq 0x6b150(%rip), %rax     # 0x299b0f
jmp 0x22e9c8
leaq 0x136ea0(%rip), %rax    # 0x365868
movq %rax, 0x575911(%rip)    # 0x7a42e0
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_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x22ea22
leaq 0x327db1(%rip), %rax    # 0x5567d1
jmp 0x22ea51
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22ea36
leaq 0x2229f2(%rip), %rax    # 0x451426
jmp 0x22ea51
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ea4a
leaq 0x6b0c7(%rip), %rax     # 0x299b0f
jmp 0x22ea51
leaq 0x13b197(%rip), %rax    # 0x369be8
movq %rax, 0x575890(%rip)    # 0x7a42e8
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_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_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_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_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 0x22eaab
leaq 0x32cf3b(%rip), %rax    # 0x55b9e4
jmp 0x22eada
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22eabf
leaq 0x226db0(%rip), %rax    # 0x45586d
jmp 0x22eada
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22ead3
leaq 0x6b03e(%rip), %rax     # 0x299b0f
jmp 0x22eada
leaq 0x13f79d(%rip), %rax    # 0x36e277
movq %rax, 0x57580f(%rip)    # 0x7a42f0
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