LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_scan_64_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_scan_64_pointer = parasail_nw_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_64_pointer = parasail_nw_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x20b3b1
leaq 0x290a51(%rip), %rax    # 0x49be00
jmp 0x20b3e0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b3c5
leaq 0x1aa3a1(%rip), %rax    # 0x3b5764
jmp 0x20b3e0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b3d9
leaq 0x8eb8d(%rip), %rax     # 0x299f64
jmp 0x20b3e0
leaq 0xb4870(%rip), %rax     # 0x2bfc50
movq %rax, 0x596e99(%rip)    # 0x7a2280
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/nw_dispatch.c
// Function: parasail_nw_stats_scan_32_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_scan_32_pointer = parasail_nw_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_32_pointer = parasail_nw_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x20b43a
leaq 0x294a58(%rip), %rax    # 0x49fe90
jmp 0x20b469
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b44e
leaq 0x1ad8e8(%rip), %rax    # 0x3b8d34
jmp 0x20b469
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b462
leaq 0x8eb04(%rip), %rax     # 0x299f64
jmp 0x20b469
leaq 0xb83ef(%rip), %rax     # 0x2c3858
movq %rax, 0x596e18(%rip)    # 0x7a2288
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/nw_dispatch.c
// Function: parasail_nw_stats_scan_16_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_scan_16_pointer = parasail_nw_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_16_pointer = parasail_nw_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x20b4c3
leaq 0x2977f3(%rip), %rax    # 0x4a2cb4
jmp 0x20b4f2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b4d7
leaq 0x1b0633(%rip), %rax    # 0x3bbb08
jmp 0x20b4f2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b4eb
leaq 0x8ea7b(%rip), %rax     # 0x299f64
jmp 0x20b4f2
leaq 0xbb7c2(%rip), %rax     # 0x2c6cb4
movq %rax, 0x596d97(%rip)    # 0x7a2290
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/nw_dispatch.c
// Function: parasail_nw_stats_scan_8_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_scan_8_pointer = parasail_nw_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_8_pointer = parasail_nw_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_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 0x20b54c
leaq 0x29a626(%rip), %rax    # 0x4a5b70
jmp 0x20b57b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b560
leaq 0x1b344e(%rip), %rax    # 0x3be9ac
jmp 0x20b57b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b574
leaq 0x8e9f2(%rip), %rax     # 0x299f64
jmp 0x20b57b
leaq 0xbe92d(%rip), %rax     # 0x2c9ea8
movq %rax, 0x596d16(%rip)    # 0x7a2298
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/nw_dispatch.c
// Function: parasail_nw_stats_striped_64_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_striped_64_pointer = parasail_nw_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_64_pointer = parasail_nw_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_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 0x20b5d5
leaq 0x2ae9f1(%rip), %rax    # 0x4b9fc4
jmp 0x20b604
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b5e9
leaq 0x1c48fd(%rip), %rax    # 0x3cfee4
jmp 0x20b604
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b5fd
leaq 0x8dbe9(%rip), %rax     # 0x2991e4
jmp 0x20b604
leaq 0xd1fc4(%rip), %rax     # 0x2dd5c8
movq %rax, 0x596c95(%rip)    # 0x7a22a0
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/nw_dispatch.c
// Function: parasail_nw_stats_striped_32_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_striped_32_pointer = parasail_nw_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_32_pointer = parasail_nw_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_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 0x20b65e
leaq 0x2b2440(%rip), %rax    # 0x4bda9c
jmp 0x20b68d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b672
leaq 0x1c7cd8(%rip), %rax    # 0x3d3348
jmp 0x20b68d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b686
leaq 0x8db60(%rip), %rax     # 0x2991e4
jmp 0x20b68d
leaq 0xd596f(%rip), %rax     # 0x2e0ffc
movq %rax, 0x596c14(%rip)    # 0x7a22a8
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/nw_dispatch.c
// Function: parasail_nw_stats_striped_16_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_striped_16_pointer = parasail_nw_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_16_pointer = parasail_nw_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_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 0x20b6e7
leaq 0x2b4ebf(%rip), %rax    # 0x4c05a4
jmp 0x20b716
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b6fb
leaq 0x1ca74f(%rip), %rax    # 0x3d5e48
jmp 0x20b716
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b70f
leaq 0x8dad7(%rip), %rax     # 0x2991e4
jmp 0x20b716
leaq 0xd8a86(%rip), %rax     # 0x2e419c
movq %rax, 0x596b93(%rip)    # 0x7a22b0
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/nw_dispatch.c
// Function: parasail_nw_stats_striped_8_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_striped_8_pointer = parasail_nw_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_8_pointer = parasail_nw_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_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 0x20b770
leaq 0x2b7a86(%rip), %rax    # 0x4c31f4
jmp 0x20b79f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b784
leaq 0x1cd3e6(%rip), %rax    # 0x3d8b68
jmp 0x20b79f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b798
leaq 0x8da4e(%rip), %rax     # 0x2991e4
jmp 0x20b79f
leaq 0xdb93d(%rip), %rax     # 0x2e70dc
movq %rax, 0x596b12(%rip)    # 0x7a22b8
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/nw_dispatch.c
// Function: parasail_nw_stats_diag_64_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_diag_64_pointer = parasail_nw_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_64_pointer = parasail_nw_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_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 0x20b7f9
leaq 0x29d22d(%rip), %rax    # 0x4a8a24
jmp 0x20b828
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b80d
leaq 0x1b6095(%rip), %rax    # 0x3c18a0
jmp 0x20b828
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b821
leaq 0x8d9c5(%rip), %rax     # 0x2991e4
jmp 0x20b828
leaq 0xc1c78(%rip), %rax     # 0x2cd4a0
movq %rax, 0x596a91(%rip)    # 0x7a22c0
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/nw_dispatch.c
// Function: parasail_nw_stats_diag_32_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_diag_32_pointer = parasail_nw_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_32_pointer = parasail_nw_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_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 0x20b882
leaq 0x2a1008(%rip), %rax    # 0x4ac888
jmp 0x20b8b1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b896
leaq 0x1b94e4(%rip), %rax    # 0x3c4d78
jmp 0x20b8b1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b8aa
leaq 0x8d93c(%rip), %rax     # 0x2991e4
jmp 0x20b8b1
leaq 0xc5943(%rip), %rax     # 0x2d11f4
movq %rax, 0x596a10(%rip)    # 0x7a22c8
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/nw_dispatch.c
// Function: parasail_nw_stats_diag_16_dispatcher
parasail_result_t* parasail_nw_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_nw_stats_diag_16_pointer = parasail_nw_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_16_pointer = parasail_nw_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_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 0x20b90b
leaq 0x2a4657(%rip), %rax    # 0x4aff60
jmp 0x20b93a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b91f
leaq 0x1bc5bf(%rip), %rax    # 0x3c7edc
jmp 0x20b93a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b933
leaq 0x8d8b3(%rip), %rax     # 0x2991e4
jmp 0x20b93a
leaq 0xc8f9a(%rip), %rax     # 0x2d48d4
movq %rax, 0x59698f(%rip)    # 0x7a22d0
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/nw_dispatch.c
// Function: parasail_nw_stats_diag_8_dispatcher
parasail_result_t* parasail_nw_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_diag_8_pointer = parasail_nw_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20b994
leaq 0x2a8926(%rip), %rax    # 0x4b42b8
jmp 0x20b9c3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20b9a8
leaq 0x1bfe7a(%rip), %rax    # 0x3cb820
jmp 0x20b9c3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20b9bc
leaq 0x8d82a(%rip), %rax     # 0x2991e4
jmp 0x20b9c3
leaq 0xccb35(%rip), %rax     # 0x2d84f8
movq %rax, 0x59690e(%rip)    # 0x7a22d8
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/nw_dispatch.c
// Function: parasail_nw_table_scan_64_dispatcher
parasail_result_t* parasail_nw_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_64_pointer = parasail_nw_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_table_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20ba1d
leaq 0x2bb4e9(%rip), %rax    # 0x4c6f04
jmp 0x20ba4c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ba31
leaq 0x1cfe15(%rip), %rax    # 0x3db844
jmp 0x20ba4c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20ba45
leaq 0x8e521(%rip), %rax     # 0x299f64
jmp 0x20ba4c
leaq 0xdf9ec(%rip), %rax     # 0x2eb438
movq %rax, 0x59688d(%rip)    # 0x7a22e0
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/nw_dispatch.c
// Function: parasail_nw_table_scan_32_dispatcher
parasail_result_t* parasail_nw_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_32_pointer = parasail_nw_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_table_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20baa6
leaq 0x2bdd60(%rip), %rax    # 0x4c9804
jmp 0x20bad5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20baba
leaq 0x1d1a9c(%rip), %rax    # 0x3dd554
jmp 0x20bad5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bace
leaq 0x8e498(%rip), %rax     # 0x299f64
jmp 0x20bad5
leaq 0xe1717(%rip), %rax     # 0x2ed1ec
movq %rax, 0x59680c(%rip)    # 0x7a22e8
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/nw_dispatch.c
// Function: parasail_nw_table_scan_16_dispatcher
parasail_result_t* parasail_nw_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_16_pointer = parasail_nw_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_16_pointer = parasail_nw_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_16_pointer = parasail_nw_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_16_pointer = parasail_nw_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_16_pointer = parasail_nw_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_table_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20bb2f
leaq 0x2bf81b(%rip), %rax    # 0x4cb348
jmp 0x20bb5e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bb43
leaq 0x1d31eb(%rip), %rax    # 0x3ded2c
jmp 0x20bb5e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bb57
leaq 0x8e40f(%rip), %rax     # 0x299f64
jmp 0x20bb5e
leaq 0xe31a2(%rip), %rax     # 0x2eed00
movq %rax, 0x59678b(%rip)    # 0x7a22f0
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/nw_dispatch.c
// Function: parasail_nw_table_scan_8_dispatcher
parasail_result_t* parasail_nw_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_scan_8_pointer = parasail_nw_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_scan_8_pointer = parasail_nw_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_scan_8_pointer = parasail_nw_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_scan_8_pointer = parasail_nw_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_scan_8_pointer = parasail_nw_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_table_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20bbb8
leaq 0x2c173e(%rip), %rax    # 0x4cd2f4
jmp 0x20bbe7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bbcc
leaq 0x1d4d46(%rip), %rax    # 0x3e0910
jmp 0x20bbe7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bbe0
leaq 0x8e386(%rip), %rax     # 0x299f64
jmp 0x20bbe7
leaq 0xe4cf1(%rip), %rax     # 0x2f08d8
movq %rax, 0x59670a(%rip)    # 0x7a22f8
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/nw_dispatch.c
// Function: parasail_nw_table_striped_64_dispatcher
parasail_result_t* parasail_nw_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_striped_64_pointer = parasail_nw_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_64_pointer = parasail_nw_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_64_pointer = parasail_nw_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_64_pointer = parasail_nw_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_64_pointer = parasail_nw_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_table_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20bc41
leaq 0x2d28b9(%rip), %rax    # 0x4de4f8
jmp 0x20bc70
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bc55
leaq 0x1e0b15(%rip), %rax    # 0x3ec768
jmp 0x20bc70
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bc69
leaq 0x8d57d(%rip), %rax     # 0x2991e4
jmp 0x20bc70
leaq 0xf1ddc(%rip), %rax     # 0x2fda4c
movq %rax, 0x596689(%rip)    # 0x7a2300
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/nw_dispatch.c
// Function: parasail_nw_table_striped_32_dispatcher
parasail_result_t* parasail_nw_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_striped_32_pointer = parasail_nw_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_32_pointer = parasail_nw_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_32_pointer = parasail_nw_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_32_pointer = parasail_nw_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_32_pointer = parasail_nw_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_table_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20bcca
leaq 0x2d4df4(%rip), %rax    # 0x4e0abc
jmp 0x20bcf9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bcde
leaq 0x1e2724(%rip), %rax    # 0x3ee400
jmp 0x20bcf9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bcf2
leaq 0x8d4f4(%rip), %rax     # 0x2991e4
jmp 0x20bcf9
leaq 0xf3a9f(%rip), %rax     # 0x2ff798
movq %rax, 0x596608(%rip)    # 0x7a2308
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/nw_dispatch.c
// Function: parasail_nw_table_striped_16_dispatcher
parasail_result_t* parasail_nw_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_striped_16_pointer = parasail_nw_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_16_pointer = parasail_nw_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_16_pointer = parasail_nw_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_16_pointer = parasail_nw_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_16_pointer = parasail_nw_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_table_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20bd53
leaq 0x2d673f(%rip), %rax    # 0x4e2490
jmp 0x20bd82
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bd67
leaq 0x1e3d3b(%rip), %rax    # 0x3efaa0
jmp 0x20bd82
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bd7b
leaq 0x8d46b(%rip), %rax     # 0x2991e4
jmp 0x20bd82
leaq 0xf538e(%rip), %rax     # 0x301110
movq %rax, 0x596587(%rip)    # 0x7a2310
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/nw_dispatch.c
// Function: parasail_nw_table_striped_8_dispatcher
parasail_result_t* parasail_nw_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_striped_8_pointer = parasail_nw_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_striped_8_pointer = parasail_nw_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_striped_8_pointer = parasail_nw_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_striped_8_pointer = parasail_nw_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_striped_8_pointer = parasail_nw_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_table_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20bddc
leaq 0x2d8952(%rip), %rax    # 0x4e472c
jmp 0x20be0b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bdf0
leaq 0x1e584a(%rip), %rax    # 0x3f1638
jmp 0x20be0b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20be04
leaq 0x8d3e2(%rip), %rax     # 0x2991e4
jmp 0x20be0b
leaq 0xf6eb1(%rip), %rax     # 0x302cbc
movq %rax, 0x596506(%rip)    # 0x7a2318
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/nw_dispatch.c
// Function: parasail_nw_table_diag_64_dispatcher
parasail_result_t* parasail_nw_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_diag_64_pointer = parasail_nw_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_diag_64_pointer = parasail_nw_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_diag_64_pointer = parasail_nw_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_diag_64_pointer = parasail_nw_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_diag_64_pointer = parasail_nw_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_table_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20be65
leaq 0x2c3a45(%rip), %rax    # 0x4cf8a8
jmp 0x20be94
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20be79
leaq 0x1d6a5d(%rip), %rax    # 0x3e28d4
jmp 0x20be94
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20be8d
leaq 0x8d359(%rip), %rax     # 0x2991e4
jmp 0x20be94
leaq 0xe6e90(%rip), %rax     # 0x2f2d24
movq %rax, 0x596485(%rip)    # 0x7a2320
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/nw_dispatch.c
// Function: parasail_nw_table_diag_32_dispatcher
parasail_result_t* parasail_nw_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_diag_32_pointer = parasail_nw_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_diag_32_pointer = parasail_nw_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_diag_32_pointer = parasail_nw_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_diag_32_pointer = parasail_nw_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_diag_32_pointer = parasail_nw_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_table_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20beee
leaq 0x2c61d4(%rip), %rax    # 0x4d20c0
jmp 0x20bf1d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bf02
leaq 0x1d873c(%rip), %rax    # 0x3e463c
jmp 0x20bf1d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bf16
leaq 0x8d2d0(%rip), %rax     # 0x2991e4
jmp 0x20bf1d
leaq 0xe8edf(%rip), %rax     # 0x2f4dfc
movq %rax, 0x596404(%rip)    # 0x7a2328
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/nw_dispatch.c
// Function: parasail_nw_table_diag_16_dispatcher
parasail_result_t* parasail_nw_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_diag_16_pointer = parasail_nw_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_diag_16_pointer = parasail_nw_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_diag_16_pointer = parasail_nw_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_diag_16_pointer = parasail_nw_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_diag_16_pointer = parasail_nw_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_table_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20bf77
leaq 0x2c889f(%rip), %rax    # 0x4d4814
jmp 0x20bfa6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20bf8b
leaq 0x1da3f3(%rip), %rax    # 0x3e637c
jmp 0x20bfa6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20bf9f
leaq 0x8d247(%rip), %rax     # 0x2991e4
jmp 0x20bfa6
leaq 0xeaeea(%rip), %rax     # 0x2f6e90
movq %rax, 0x596383(%rip)    # 0x7a2330
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