LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d015
leaq 0x2e5b49(%rip), %rax    # 0x4f2b5c
jmp 0x20d044
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d029
leaq 0x1f0ae9(%rip), %rax    # 0x3fdb10
jmp 0x20d044
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d03d
leaq 0x8e529(%rip), %rax     # 0x29b564
jmp 0x20d044
leaq 0xea168(%rip), %rax     # 0x2f71ac
movq %rax, 0x5cb295(%rip)    # 0x7d82e0
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d09e
leaq 0x2e7618(%rip), %rax    # 0x4f46b4
jmp 0x20d0cd
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d0b2
leaq 0x1f252c(%rip), %rax    # 0x3ff5dc
jmp 0x20d0cd
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d0c6
leaq 0x8e4a0(%rip), %rax     # 0x29b564
jmp 0x20d0cd
leaq 0xec283(%rip), %rax     # 0x2f9350
movq %rax, 0x5cb214(%rip)    # 0x7d82e8
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d127
leaq 0x2e9293(%rip), %rax    # 0x4f63b8
jmp 0x20d156
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d13b
leaq 0x1f4027(%rip), %rax    # 0x401160
jmp 0x20d156
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d14f
leaq 0x8e417(%rip), %rax     # 0x29b564
jmp 0x20d156
leaq 0xee1f2(%rip), %rax     # 0x2fb348
movq %rax, 0x5cb193(%rip)    # 0x7d82f0
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d1b0
leaq 0x2ebede(%rip), %rax    # 0x4f908c
jmp 0x20d1df
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d1c4
leaq 0x1f60fe(%rip), %rax    # 0x4032c0
jmp 0x20d1df
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d1d8
leaq 0x8e38e(%rip), %rax     # 0x29b564
jmp 0x20d1df
leaq 0xf0619(%rip), %rax     # 0x2fd7f8
movq %rax, 0x5cb112(%rip)    # 0x7d82f8
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d239
leaq 0x2fdacd(%rip), %rax    # 0x50ad04
jmp 0x20d268
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d24d
leaq 0x202285(%rip), %rax    # 0x40f4d0
jmp 0x20d268
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d261
leaq 0x8d57d(%rip), %rax     # 0x29a7dc
jmp 0x20d268
leaq 0xfe670(%rip), %rax     # 0x30b8d8
movq %rax, 0x5cb091(%rip)    # 0x7d8300
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d2c2
leaq 0x2ff2ec(%rip), %rax    # 0x50c5ac
jmp 0x20d2f1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d2d6
leaq 0x203af0(%rip), %rax    # 0x410dc4
jmp 0x20d2f1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d2ea
leaq 0x8d4f4(%rip), %rax     # 0x29a7dc
jmp 0x20d2f1
leaq 0x1006ef(%rip), %rax    # 0x30d9e0
movq %rax, 0x5cb010(%rip)    # 0x7d8308
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d34b
leaq 0x300e1b(%rip), %rax    # 0x50e164
jmp 0x20d37a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d35f
leaq 0x205343(%rip), %rax    # 0x4126a0
jmp 0x20d37a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d373
leaq 0x8d46b(%rip), %rax     # 0x29a7dc
jmp 0x20d37a
leaq 0x1023a2(%rip), %rax    # 0x30f71c
movq %rax, 0x5caf8f(%rip)    # 0x7d8310
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d3d4
leaq 0x303c82(%rip), %rax    # 0x511054
jmp 0x20d403
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d3e8
leaq 0x207466(%rip), %rax    # 0x41484c
jmp 0x20d403
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d3fc
leaq 0x8d3e2(%rip), %rax     # 0x29a7dc
jmp 0x20d403
leaq 0x104809(%rip), %rax    # 0x311c0c
movq %rax, 0x5caf0e(%rip)    # 0x7d8318
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d45d
leaq 0x2efce5(%rip), %rax    # 0x4fd140
jmp 0x20d48c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d471
leaq 0x1f8769(%rip), %rax    # 0x405bd8
jmp 0x20d48c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d485
leaq 0x8d359(%rip), %rax     # 0x29a7dc
jmp 0x20d48c
leaq 0xf3748(%rip), %rax     # 0x300bd4
movq %rax, 0x5cae8d(%rip)    # 0x7d8320
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d4e6
leaq 0x2f1b78(%rip), %rax    # 0x4ff05c
jmp 0x20d515
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d4fa
leaq 0x1fa0ec(%rip), %rax    # 0x4075e4
jmp 0x20d515
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d50e
leaq 0x8d2d0(%rip), %rax     # 0x29a7dc
jmp 0x20d515
leaq 0xf585f(%rip), %rax     # 0x302d74
movq %rax, 0x5cae0c(%rip)    # 0x7d8328
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x20d56f
leaq 0x2f4077(%rip), %rax    # 0x5015e4
jmp 0x20d59e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d583
leaq 0x1fbd33(%rip), %rax    # 0x4092b4
jmp 0x20d59e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d597
leaq 0x8d247(%rip), %rax     # 0x29a7dc
jmp 0x20d59e
leaq 0xf77d2(%rip), %rax     # 0x304d70
movq %rax, 0x5cad8b(%rip)    # 0x7d8330
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_table_diag_8_dispatcher
parasail_result_t* parasail_nw_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_table_diag_8_pointer = parasail_nw_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_table_diag_8_pointer = parasail_nw_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_table_diag_8_pointer = parasail_nw_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_table_diag_8_pointer = parasail_nw_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_table_diag_8_pointer = parasail_nw_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_table_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d5f8
leaq 0x2f7a96(%rip), %rax    # 0x50508c
jmp 0x20d627
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d60c
leaq 0x1fe26e(%rip), %rax    # 0x40b878
jmp 0x20d627
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d620
leaq 0x8d1be(%rip), %rax     # 0x29a7dc
jmp 0x20d627
leaq 0xf9f79(%rip), %rax     # 0x3075a0
movq %rax, 0x5cad0a(%rip)    # 0x7d8338
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_64_dispatcher
parasail_result_t* parasail_nw_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_scan_64_pointer = parasail_nw_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_64_pointer = parasail_nw_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_64_pointer = parasail_nw_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_64_pointer = parasail_nw_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_64_pointer = parasail_nw_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_table_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d681
leaq 0x307d09(%rip), %rax    # 0x515388
jmp 0x20d6b0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d695
leaq 0x20a5dd(%rip), %rax    # 0x417c70
jmp 0x20d6b0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d6a9
leaq 0x8debd(%rip), %rax     # 0x29b564
jmp 0x20d6b0
leaq 0x107af8(%rip), %rax    # 0x3151a8
movq %rax, 0x5cac89(%rip)    # 0x7d8340
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_32_dispatcher
parasail_result_t* parasail_nw_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_scan_32_pointer = parasail_nw_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_32_pointer = parasail_nw_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_32_pointer = parasail_nw_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_32_pointer = parasail_nw_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_32_pointer = parasail_nw_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_table_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d70a
leaq 0x30b23c(%rip), %rax    # 0x518944
jmp 0x20d739
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d71e
leaq 0x20d8f0(%rip), %rax    # 0x41b00c
jmp 0x20d739
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d732
leaq 0x8de34(%rip), %rax     # 0x29b564
jmp 0x20d739
leaq 0x10bd17(%rip), %rax    # 0x319450
movq %rax, 0x5cac08(%rip)    # 0x7d8348
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_16_dispatcher
parasail_result_t* parasail_nw_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_scan_16_pointer = parasail_nw_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_16_pointer = parasail_nw_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_16_pointer = parasail_nw_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_16_pointer = parasail_nw_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_16_pointer = parasail_nw_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_table_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d793
leaq 0x30e913(%rip), %rax    # 0x51c0a4
jmp 0x20d7c2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d7a7
leaq 0x210ddf(%rip), %rax    # 0x41e584
jmp 0x20d7c2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d7bb
leaq 0x8ddab(%rip), %rax     # 0x29b564
jmp 0x20d7c2
leaq 0x10f956(%rip), %rax    # 0x31d118
movq %rax, 0x5cab87(%rip)    # 0x7d8350
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_scan_8_dispatcher
parasail_result_t* parasail_nw_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_scan_8_pointer = parasail_nw_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_scan_8_pointer = parasail_nw_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_scan_8_pointer = parasail_nw_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_scan_8_pointer = parasail_nw_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_scan_8_pointer = parasail_nw_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_table_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_stats_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d81c
leaq 0x3134d2(%rip), %rax    # 0x520cec
jmp 0x20d84b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d830
leaq 0x214c2e(%rip), %rax    # 0x42245c
jmp 0x20d84b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d844
leaq 0x8dd22(%rip), %rax     # 0x29b564
jmp 0x20d84b
leaq 0x113ebd(%rip), %rax    # 0x321708
movq %rax, 0x5cab06(%rip)    # 0x7d8358
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_striped_64_dispatcher
parasail_result_t* parasail_nw_stats_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_striped_64_pointer = parasail_nw_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_striped_64_pointer = parasail_nw_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_striped_64_pointer = parasail_nw_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_striped_64_pointer = parasail_nw_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_striped_64_pointer = parasail_nw_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_table_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d8a5
leaq 0x32e355(%rip), %rax    # 0x53bbf8
jmp 0x20d8d4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d8b9
leaq 0x22a8e1(%rip), %rax    # 0x438198
jmp 0x20d8d4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d8cd
leaq 0x8cf11(%rip), %rax     # 0x29a7dc
jmp 0x20d8d4
leaq 0x12cb84(%rip), %rax    # 0x33a458
movq %rax, 0x5caa85(%rip)    # 0x7d8360
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_striped_32_dispatcher
parasail_result_t* parasail_nw_stats_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_striped_32_pointer = parasail_nw_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_striped_32_pointer = parasail_nw_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_striped_32_pointer = parasail_nw_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_striped_32_pointer = parasail_nw_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_striped_32_pointer = parasail_nw_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_table_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d92e
leaq 0x33168c(%rip), %rax    # 0x53efb8
jmp 0x20d95d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d942
leaq 0x22dbb0(%rip), %rax    # 0x43b4f0
jmp 0x20d95d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d956
leaq 0x8ce88(%rip), %rax     # 0x29a7dc
jmp 0x20d95d
leaq 0x130e63(%rip), %rax    # 0x33e7c0
movq %rax, 0x5caa04(%rip)    # 0x7d8368
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_striped_16_dispatcher
parasail_result_t* parasail_nw_stats_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_striped_16_pointer = parasail_nw_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_striped_16_pointer = parasail_nw_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_striped_16_pointer = parasail_nw_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_striped_16_pointer = parasail_nw_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_striped_16_pointer = parasail_nw_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_table_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20d9b7
leaq 0x334d53(%rip), %rax    # 0x542708
jmp 0x20d9e6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20d9cb
leaq 0x230f2b(%rip), %rax    # 0x43e8f4
jmp 0x20d9e6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20d9df
leaq 0x8cdff(%rip), %rax     # 0x29a7dc
jmp 0x20d9e6
leaq 0x134942(%rip), %rax    # 0x342328
movq %rax, 0x5ca983(%rip)    # 0x7d8370
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_striped_8_dispatcher
parasail_result_t* parasail_nw_stats_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_striped_8_pointer = parasail_nw_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_striped_8_pointer = parasail_nw_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_striped_8_pointer = parasail_nw_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_striped_8_pointer = parasail_nw_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_striped_8_pointer = parasail_nw_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_table_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20da40
leaq 0x33a6fa(%rip), %rax    # 0x548138
jmp 0x20da6f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20da54
leaq 0x2353e2(%rip), %rax    # 0x442e34
jmp 0x20da6f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20da68
leaq 0x8cd76(%rip), %rax     # 0x29a7dc
jmp 0x20da6f
leaq 0x139185(%rip), %rax    # 0x346bf4
movq %rax, 0x5ca902(%rip)    # 0x7d8378
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_diag_64_dispatcher
parasail_result_t* parasail_nw_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_diag_64_pointer = parasail_nw_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_diag_64_pointer = parasail_nw_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_diag_64_pointer = parasail_nw_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_diag_64_pointer = parasail_nw_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_diag_64_pointer = parasail_nw_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_stats_table_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_stats_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20dac9
leaq 0x318911(%rip), %rax    # 0x5263d8
jmp 0x20daf8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20dadd
leaq 0x219729(%rip), %rax    # 0x427204
jmp 0x20daf8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20daf1
leaq 0x8cced(%rip), %rax     # 0x29a7dc
jmp 0x20daf8
leaq 0x11975c(%rip), %rax    # 0x327254
movq %rax, 0x5ca881(%rip)    # 0x7d8380
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_O3/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_table_diag_32_dispatcher
parasail_result_t* parasail_nw_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_table_diag_32_pointer = parasail_nw_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_diag_32_pointer = parasail_nw_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_diag_32_pointer = parasail_nw_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_diag_32_pointer = parasail_nw_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_diag_32_pointer = parasail_nw_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_stats_table_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_stats_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20db52
leaq 0x31c5e8(%rip), %rax    # 0x52a138
jmp 0x20db81
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20db66
leaq 0x21cbac(%rip), %rax    # 0x42a710
jmp 0x20db81
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20db7a
leaq 0x8cc64(%rip), %rax     # 0x29a7dc
jmp 0x20db81
leaq 0x11da73(%rip), %rax    # 0x32b5f4
movq %rax, 0x5ca800(%rip)    # 0x7d8388
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