LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_32_dispatcher
parasail_result_t* parasail_nw_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_diag_32_pointer = parasail_nw_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_32_pointer = parasail_nw_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1ade6a
leaq 0x2aeddc(%rip), %rax    # 0x45cc44
jmp 0x1ade99
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ade7e
leaq 0x1bbcd4(%rip), %rax    # 0x369b50
jmp 0x1ade99
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ade92
leaq 0x8dfa8(%rip), %rax     # 0x23be38
jmp 0x1ade99
leaq 0xabde3(%rip), %rax     # 0x259c7c
movq %rax, 0x58d3c8(%rip)    # 0x73b268
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_16_dispatcher
parasail_result_t* parasail_nw_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_diag_16_pointer = parasail_nw_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_16_pointer = parasail_nw_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1adef3
leaq 0x2b0bff(%rip), %rax    # 0x45eaf0
jmp 0x1adf22
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1adf07
leaq 0x1bd623(%rip), %rax    # 0x36b528
jmp 0x1adf22
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1adf1b
leaq 0x8df1f(%rip), %rax     # 0x23be38
jmp 0x1adf22
leaq 0xada3e(%rip), %rax     # 0x25b960
movq %rax, 0x58d347(%rip)    # 0x73b270
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_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_diag_8_dispatcher
parasail_result_t* parasail_nw_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_diag_8_pointer = parasail_nw_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_diag_8_pointer = parasail_nw_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_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 0x5672cf
testl %eax, %eax
je 0x1adf7c
leaq 0x2b3346(%rip), %rax    # 0x4612c0
jmp 0x1adfab
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1adf90
leaq 0x1bf36a(%rip), %rax    # 0x36d2f8
jmp 0x1adfab
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1adfa4
leaq 0x8de96(%rip), %rax     # 0x23be38
jmp 0x1adfab
leaq 0xafadd(%rip), %rax     # 0x25da88
movq %rax, 0x58d2c6(%rip)    # 0x73b278
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae005
leaq 0x2bd475(%rip), %rax    # 0x46b478
jmp 0x1ae034
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae019
leaq 0x1c8d11(%rip), %rax    # 0x376d28
jmp 0x1ae034
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae02d
leaq 0x8edd1(%rip), %rax     # 0x23cdfc
jmp 0x1ae034
leaq 0xba4b8(%rip), %rax     # 0x2684ec
movq %rax, 0x58d245(%rip)    # 0x73b280
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae08e
leaq 0x2c1720(%rip), %rax    # 0x46f7ac
jmp 0x1ae0bd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae0a2
leaq 0x1ccc8c(%rip), %rax    # 0x37ad2c
jmp 0x1ae0bd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae0b6
leaq 0x8ed48(%rip), %rax     # 0x23cdfc
jmp 0x1ae0bd
leaq 0xbf20f(%rip), %rax     # 0x26d2cc
movq %rax, 0x58d1c4(%rip)    # 0x73b288
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae117
leaq 0x2c492f(%rip), %rax    # 0x472a44
jmp 0x1ae146
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae12b
leaq 0x1cfea7(%rip), %rax    # 0x37dfd0
jmp 0x1ae146
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae13f
leaq 0x8ecbf(%rip), %rax     # 0x23cdfc
jmp 0x1ae146
leaq 0xc2ad6(%rip), %rax     # 0x270c1c
movq %rax, 0x58d143(%rip)    # 0x73b290
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae1a0
leaq 0x2c7bfe(%rip), %rax    # 0x475d9c
jmp 0x1ae1cf
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae1b4
leaq 0x1d31ba(%rip), %rax    # 0x38136c
jmp 0x1ae1cf
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae1c8
leaq 0x8ec36(%rip), %rax     # 0x23cdfc
jmp 0x1ae1cf
leaq 0xc6149(%rip), %rax     # 0x274318
movq %rax, 0x58d0c2(%rip)    # 0x73b298
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae229
leaq 0x2db79d(%rip), %rax    # 0x4899c4
jmp 0x1ae258
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae23d
leaq 0x1e4fed(%rip), %rax    # 0x393228
jmp 0x1ae258
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae251
leaq 0x8dbe9(%rip), %rax     # 0x23be38
jmp 0x1ae258
leaq 0xda9c8(%rip), %rax     # 0x288c20
movq %rax, 0x58d041(%rip)    # 0x73b2a0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae2b2
leaq 0x2df334(%rip), %rax    # 0x48d5e4
jmp 0x1ae2e1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae2c6
leaq 0x1e8b44(%rip), %rax    # 0x396e08
jmp 0x1ae2e1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae2da
leaq 0x8db60(%rip), %rax     # 0x23be38
jmp 0x1ae2e1
leaq 0xdf36b(%rip), %rax     # 0x28d64c
movq %rax, 0x58cfc0(%rip)    # 0x73b2a8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae33b
leaq 0x2e22f3(%rip), %rax    # 0x49062c
jmp 0x1ae36a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae34f
leaq 0x1ebc63(%rip), %rax    # 0x399fb0
jmp 0x1ae36a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae363
leaq 0x8dad7(%rip), %rax     # 0x23be38
jmp 0x1ae36a
leaq 0xe2ad2(%rip), %rax     # 0x290e3c
movq %rax, 0x58cf3f(%rip)    # 0x73b2b0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae3c4
leaq 0x2e54b2(%rip), %rax    # 0x493874
jmp 0x1ae3f3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae3d8
leaq 0x1eeefe(%rip), %rax    # 0x39d2d4
jmp 0x1ae3f3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae3ec
leaq 0x8da4e(%rip), %rax     # 0x23be38
jmp 0x1ae3f3
leaq 0xe5f71(%rip), %rax     # 0x294364
movq %rax, 0x58cebe(%rip)    # 0x73b2b8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae44d
leaq 0x2cac99(%rip), %rax    # 0x4790e4
jmp 0x1ae47c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae461
leaq 0x1d62c5(%rip), %rax    # 0x384724
jmp 0x1ae47c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae475
leaq 0x8d9c5(%rip), %rax     # 0x23be38
jmp 0x1ae47c
leaq 0xc9954(%rip), %rax     # 0x277dd0
movq %rax, 0x58ce3d(%rip)    # 0x73b2c0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae4d6
leaq 0x2ce698(%rip), %rax    # 0x47cb6c
jmp 0x1ae505
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae4ea
leaq 0x1d9c20(%rip), %rax    # 0x388108
jmp 0x1ae505
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae4fe
leaq 0x8d93c(%rip), %rax     # 0x23be38
jmp 0x1ae505
leaq 0xcde67(%rip), %rax     # 0x27c36c
movq %rax, 0x58cdbc(%rip)    # 0x73b2c8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae55f
leaq 0x2d1bf3(%rip), %rax    # 0x480150
jmp 0x1ae58e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae573
leaq 0x1dce67(%rip), %rax    # 0x38b3d8
jmp 0x1ae58e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae587
leaq 0x8d8b3(%rip), %rax     # 0x23be38
jmp 0x1ae58e
leaq 0xd162a(%rip), %rax     # 0x27fbb8
movq %rax, 0x58cd3b(%rip)    # 0x73b2d0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae5e8
leaq 0x2d5ef6(%rip), %rax    # 0x4844dc
jmp 0x1ae617
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae5fc
leaq 0x1e0652(%rip), %rax    # 0x38ec4c
jmp 0x1ae617
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae610
leaq 0x8d82a(%rip), %rax     # 0x23be38
jmp 0x1ae617
leaq 0xd50e9(%rip), %rax     # 0x283700
movq %rax, 0x58ccba(%rip)    # 0x73b2d8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae671
leaq 0x2e99bd(%rip), %rax    # 0x49802c
jmp 0x1ae6a0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae685
leaq 0x1f1f1d(%rip), %rax    # 0x3a05a0
jmp 0x1ae6a0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae699
leaq 0x8e765(%rip), %rax     # 0x23cdfc
jmp 0x1ae6a0
leaq 0xeaa98(%rip), %rax     # 0x299138
movq %rax, 0x58cc39(%rip)    # 0x73b2e0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae6fa
leaq 0x2ebcc0(%rip), %rax    # 0x49a3b8
jmp 0x1ae729
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae70e
leaq 0x1f3d60(%rip), %rax    # 0x3a246c
jmp 0x1ae729
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae722
leaq 0x8e6dc(%rip), %rax     # 0x23cdfc
jmp 0x1ae729
leaq 0xed04b(%rip), %rax     # 0x29b774
movq %rax, 0x58cbb8(%rip)    # 0x73b2e8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae783
leaq 0x2edaef(%rip), %rax    # 0x49c270
jmp 0x1ae7b2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae797
leaq 0x1f594b(%rip), %rax    # 0x3a40e0
jmp 0x1ae7b2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae7ab
leaq 0x8e653(%rip), %rax     # 0x23cdfc
jmp 0x1ae7b2
leaq 0xeefa6(%rip), %rax     # 0x29d758
movq %rax, 0x58cb37(%rip)    # 0x73b2f0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae80c
leaq 0x2efd42(%rip), %rax    # 0x49e54c
jmp 0x1ae83b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae820
leaq 0x1f7812(%rip), %rax    # 0x3a6030
jmp 0x1ae83b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae834
leaq 0x8e5ca(%rip), %rax     # 0x23cdfc
jmp 0x1ae83b
leaq 0xf0ecd(%rip), %rax     # 0x29f708
movq %rax, 0x58cab6(%rip)    # 0x73b2f8
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae895
leaq 0x3018a5(%rip), %rax    # 0x4b0138
jmp 0x1ae8c4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae8a9
leaq 0x20419d(%rip), %rax    # 0x3b2a44
jmp 0x1ae8c4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae8bd
leaq 0x8d57d(%rip), %rax     # 0x23be38
jmp 0x1ae8c4
leaq 0xff410(%rip), %rax     # 0x2adcd4
movq %rax, 0x58ca35(%rip)    # 0x73b300
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae91e
leaq 0x303990(%rip), %rax    # 0x4b22ac
jmp 0x1ae94d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae932
leaq 0x2061bc(%rip), %rax    # 0x3b4aec
jmp 0x1ae94d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae946
leaq 0x8d4f4(%rip), %rax     # 0x23be38
jmp 0x1ae94d
leaq 0x101b47(%rip), %rax    # 0x2b0494
movq %rax, 0x58c9b4(%rip)    # 0x73b308
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1ae9a7
leaq 0x3059e7(%rip), %rax    # 0x4b438c
jmp 0x1ae9d6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1ae9bb
leaq 0x208043(%rip), %rax    # 0x3b69fc
jmp 0x1ae9d6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1ae9cf
leaq 0x8d46b(%rip), %rax     # 0x23be38
jmp 0x1ae9d6
leaq 0x103c7e(%rip), %rax    # 0x2b2654
movq %rax, 0x58c933(%rip)    # 0x73b310
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1aea30
leaq 0x307eba(%rip), %rax    # 0x4b68e8
jmp 0x1aea5f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aea44
leaq 0x20a13a(%rip), %rax    # 0x3b8b7c
jmp 0x1aea5f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aea58
leaq 0x8d3e2(%rip), %rax     # 0x23be38
jmp 0x1aea5f
leaq 0x105dad(%rip), %rax    # 0x2b480c
movq %rax, 0x58c8b2(%rip)    # 0x73b318
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