LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_64_pointer = parasail_sw_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x214665
leaq 0x272101(%rip), %rax    # 0x486764
jmp 0x214694
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214679
leaq 0x18e8e5(%rip), %rax    # 0x3a2f5c
jmp 0x214694
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21468d
leaq 0x863e5(%rip), %rax     # 0x29aa70
jmp 0x214694
leaq 0x97abc(%rip), %rax     # 0x2ac150
movq %rax, 0x58e445(%rip)    # 0x7a2ae0
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/sw_dispatch.c
// Function: parasail_sw_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_32_pointer = parasail_sw_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x2146ee
leaq 0x273bc0(%rip), %rax    # 0x4882ac
jmp 0x21471d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214702
leaq 0x190084(%rip), %rax    # 0x3a4784
jmp 0x21471d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214716
leaq 0x8635c(%rip), %rax     # 0x29aa70
jmp 0x21471d
leaq 0x9949b(%rip), %rax     # 0x2adbb8
movq %rax, 0x58e3c4(%rip)    # 0x7a2ae8
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/sw_dispatch.c
// Function: parasail_sw_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_16_pointer = parasail_sw_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x214777
leaq 0x275227(%rip), %rax    # 0x48999c
jmp 0x2147a6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21478b
leaq 0x1916cf(%rip), %rax    # 0x3a5e58
jmp 0x2147a6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21479f
leaq 0x862d3(%rip), %rax     # 0x29aa70
jmp 0x2147a6
leaq 0x9abea(%rip), %rax     # 0x2af390
movq %rax, 0x58e343(%rip)    # 0x7a2af0
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/sw_dispatch.c
// Function: parasail_sw_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_8_pointer = parasail_sw_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x214800
leaq 0x276862(%rip), %rax    # 0x48b060
jmp 0x21482f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214814
leaq 0x192d0a(%rip), %rax    # 0x3a751c
jmp 0x21482f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214828
leaq 0x8624a(%rip), %rax     # 0x29aa70
jmp 0x21482f
leaq 0x9c4ed(%rip), %rax     # 0x2b0d1c
movq %rax, 0x58e2c2(%rip)    # 0x7a2af8
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/sw_dispatch.c
// Function: parasail_sw_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_64_pointer = parasail_sw_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x214889
leaq 0x282edd(%rip), %rax    # 0x497764
jmp 0x2148b8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21489d
leaq 0x19c2c1(%rip), %rax    # 0x3b0b5c
jmp 0x2148b8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2148b1
leaq 0x85345(%rip), %rax     # 0x299bf4
jmp 0x2148b8
leaq 0xa6944(%rip), %rax     # 0x2bb1fc
movq %rax, 0x58e241(%rip)    # 0x7a2b00
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/sw_dispatch.c
// Function: parasail_sw_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_32_pointer = parasail_sw_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x214912
leaq 0x284614(%rip), %rax    # 0x498f24
jmp 0x214941
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214926
leaq 0x19d874(%rip), %rax    # 0x3b2198
jmp 0x214941
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21493a
leaq 0x852bc(%rip), %rax     # 0x299bf4
jmp 0x214941
leaq 0xa8087(%rip), %rax     # 0x2bc9c8
movq %rax, 0x58e1c0(%rip)    # 0x7a2b08
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/sw_dispatch.c
// Function: parasail_sw_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_16_pointer = parasail_sw_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x21499b
leaq 0x285a37(%rip), %rax    # 0x49a3d0
jmp 0x2149ca
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2149af
leaq 0x19ec8f(%rip), %rax    # 0x3b363c
jmp 0x2149ca
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2149c3
leaq 0x85233(%rip), %rax     # 0x299bf4
jmp 0x2149ca
leaq 0xa954a(%rip), %rax     # 0x2bdf14
movq %rax, 0x58e13f(%rip)    # 0x7a2b10
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/sw_dispatch.c
// Function: parasail_sw_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_8_pointer = parasail_sw_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x214a24
leaq 0x286e86(%rip), %rax    # 0x49b8a8
jmp 0x214a53
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214a38
leaq 0x1a00da(%rip), %rax    # 0x3b4b10
jmp 0x214a53
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214a4c
leaq 0x851aa(%rip), %rax     # 0x299bf4
jmp 0x214a53
leaq 0xaabf5(%rip), %rax     # 0x2bf648
movq %rax, 0x58e0be(%rip)    # 0x7a2b18
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/sw_dispatch.c
// Function: parasail_sw_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_64_pointer = parasail_sw_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x214aad
leaq 0x278549(%rip), %rax    # 0x48cff4
jmp 0x214adc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214ac1
leaq 0x194491(%rip), %rax    # 0x3a8f50
jmp 0x214adc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214ad5
leaq 0x85121(%rip), %rax     # 0x299bf4
jmp 0x214adc
leaq 0x9e024(%rip), %rax     # 0x2b2b00
movq %rax, 0x58e03d(%rip)    # 0x7a2b20
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/sw_dispatch.c
// Function: parasail_sw_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_32_pointer = parasail_sw_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x214b36
leaq 0x27a4c8(%rip), %rax    # 0x48effc
jmp 0x214b65
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214b4a
leaq 0x195e0c(%rip), %rax    # 0x3aa954
jmp 0x214b65
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214b5e
leaq 0x85098(%rip), %rax     # 0x299bf4
jmp 0x214b65
leaq 0x9fcb7(%rip), %rax     # 0x2b481c
movq %rax, 0x58dfbc(%rip)    # 0x7a2b28
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/sw_dispatch.c
// Function: parasail_sw_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_16_pointer = parasail_sw_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x214bbf
leaq 0x27c90b(%rip), %rax    # 0x4914c8
jmp 0x214bee
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214bd3
leaq 0x1979cb(%rip), %rax    # 0x3ac59c
jmp 0x214bee
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214be7
leaq 0x8500f(%rip), %rax     # 0x299bf4
jmp 0x214bee
leaq 0xa1a8e(%rip), %rax     # 0x2b667c
movq %rax, 0x58df3b(%rip)    # 0x7a2b30
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/sw_dispatch.c
// Function: parasail_sw_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_8_pointer = parasail_sw_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x214c48
leaq 0x27ff36(%rip), %rax    # 0x494b7c
jmp 0x214c77
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214c5c
leaq 0x199dee(%rip), %rax    # 0x3aea48
jmp 0x214c77
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214c70
leaq 0x84f86(%rip), %rax     # 0x299bf4
jmp 0x214c77
leaq 0xa4289(%rip), %rax     # 0x2b8f00
movq %rax, 0x58deba(%rip)    # 0x7a2b38
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_64_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_scan_64_pointer = parasail_sw_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_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 0x214cd1
leaq 0x289e15(%rip), %rax    # 0x49eae4
jmp 0x214d00
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214ce5
leaq 0x1a2fad(%rip), %rax    # 0x3b7c90
jmp 0x214d00
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214cf9
leaq 0x85d79(%rip), %rax     # 0x29aa70
jmp 0x214d00
leaq 0xad8f4(%rip), %rax     # 0x2c25f4
movq %rax, 0x58de39(%rip)    # 0x7a2b40
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_32_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_scan_32_pointer = parasail_sw_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_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 0x214d5a
leaq 0x28d1f0(%rip), %rax    # 0x4a1f48
jmp 0x214d89
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214d6e
leaq 0x1a5fd8(%rip), %rax    # 0x3bad44
jmp 0x214d89
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214d82
leaq 0x85cf0(%rip), %rax     # 0x29aa70
jmp 0x214d89
leaq 0xb0f47(%rip), %rax     # 0x2c5cd0
movq %rax, 0x58ddb8(%rip)    # 0x7a2b48
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_16_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_scan_16_pointer = parasail_sw_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_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 0x214de3
leaq 0x290003(%rip), %rax    # 0x4a4de4
jmp 0x214e12
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214df7
leaq 0x1a8d8b(%rip), %rax    # 0x3bdb80
jmp 0x214e12
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214e0b
leaq 0x85c67(%rip), %rax     # 0x29aa70
jmp 0x214e12
leaq 0xb4192(%rip), %rax     # 0x2c8fa4
movq %rax, 0x58dd37(%rip)    # 0x7a2b50
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_8_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_scan_8_pointer = parasail_sw_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_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 0x214e6c
leaq 0x292e3e(%rip), %rax    # 0x4a7ca8
jmp 0x214e9b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214e80
leaq 0x1abbde(%rip), %rax    # 0x3c0a5c
jmp 0x214e9b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214e94
leaq 0x85bde(%rip), %rax     # 0x29aa70
jmp 0x214e9b
leaq 0xb75a1(%rip), %rax     # 0x2cc43c
movq %rax, 0x58dcb6(%rip)    # 0x7a2b58
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_64_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_striped_64_pointer = parasail_sw_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x214ef5
leaq 0x2a783d(%rip), %rax    # 0x4bc730
jmp 0x214f24
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214f09
leaq 0x1bd2c5(%rip), %rax    # 0x3d21cc
jmp 0x214f24
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214f1d
leaq 0x84cd9(%rip), %rax     # 0x299bf4
jmp 0x214f24
leaq 0xcad88(%rip), %rax     # 0x2dfcac
movq %rax, 0x58dc35(%rip)    # 0x7a2b60
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_32_dispatcher
parasail_result_t* parasail_sw_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x214f7e
leaq 0x2aa7c4(%rip), %rax    # 0x4bf740
jmp 0x214fad
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x214f92
leaq 0x1c004c(%rip), %rax    # 0x3d4fdc
jmp 0x214fad
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x214fa6
leaq 0x84c50(%rip), %rax     # 0x299bf4
jmp 0x214fad
leaq 0xce16f(%rip), %rax     # 0x2e311c
movq %rax, 0x58dbb4(%rip)    # 0x7a2b68
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_16_dispatcher
parasail_result_t* parasail_sw_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x215007
leaq 0x2ad2eb(%rip), %rax    # 0x4c22f0
jmp 0x215036
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21501b
leaq 0x1c2bdf(%rip), %rax    # 0x3d7bf8
jmp 0x215036
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21502f
leaq 0x84bc7(%rip), %rax     # 0x299bf4
jmp 0x215036
leaq 0xd10b6(%rip), %rax     # 0x2e60ec
movq %rax, 0x58db33(%rip)    # 0x7a2b70
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_8_dispatcher
parasail_result_t* parasail_sw_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x215090
leaq 0x2afeaa(%rip), %rax    # 0x4c4f38
jmp 0x2150bf
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2150a4
leaq 0x1c5816(%rip), %rax    # 0x3da8b8
jmp 0x2150bf
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2150b8
leaq 0x84b3e(%rip), %rax     # 0x299bf4
jmp 0x2150bf
leaq 0xd4249(%rip), %rax     # 0x2e9308
movq %rax, 0x58dab2(%rip)    # 0x7a2b78
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/sw_dispatch.c
// Function: parasail_sw_stats_diag_64_dispatcher
parasail_result_t* parasail_sw_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x215119
leaq 0x296469(%rip), %rax    # 0x4ab580
jmp 0x215148
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21512d
leaq 0x1aec5d(%rip), %rax    # 0x3c3d88
jmp 0x215148
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215141
leaq 0x84ab5(%rip), %rax     # 0x299bf4
jmp 0x215148
leaq 0xbadb8(%rip), %rax     # 0x2cff00
movq %rax, 0x58da31(%rip)    # 0x7a2b80
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/sw_dispatch.c
// Function: parasail_sw_stats_diag_32_dispatcher
parasail_result_t* parasail_sw_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2151a2
leaq 0x299df4(%rip), %rax    # 0x4aef94
jmp 0x2151d1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2151b6
leaq 0x1b1ea8(%rip), %rax    # 0x3c705c
jmp 0x2151d1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2151ca
leaq 0x84a2c(%rip), %rax     # 0x299bf4
jmp 0x2151d1
leaq 0xbe703(%rip), %rax     # 0x2d38d4
movq %rax, 0x58d9b0(%rip)    # 0x7a2b88
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/sw_dispatch.c
// Function: parasail_sw_stats_diag_16_dispatcher
parasail_result_t* parasail_sw_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21522b
leaq 0x29dca3(%rip), %rax    # 0x4b2ecc
jmp 0x21525a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21523f
leaq 0x1b555b(%rip), %rax    # 0x3ca798
jmp 0x21525a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215253
leaq 0x849a3(%rip), %rax     # 0x299bf4
jmp 0x21525a
leaq 0xc215e(%rip), %rax     # 0x2d73b8
movq %rax, 0x58d92f(%rip)    # 0x7a2b90
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