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_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 0x5672cf
testl %eax, %eax
je 0x1aeab9
leaq 0x2f2329(%rip), %rax    # 0x4a0de0
jmp 0x1aeae8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aeacd
leaq 0x1f97fd(%rip), %rax    # 0x3a82c8
jmp 0x1aeae8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aeae1
leaq 0x8d359(%rip), %rax     # 0x23be38
jmp 0x1aeae8
leaq 0xf34d4(%rip), %rax     # 0x2a1fbc
movq %rax, 0x58c831(%rip)    # 0x73b320
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_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 0x5672cf
testl %eax, %eax
je 0x1aeb42
leaq 0x2f4798(%rip), %rax    # 0x4a32d8
jmp 0x1aeb71
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aeb56
leaq 0x1fb6f0(%rip), %rax    # 0x3aa244
jmp 0x1aeb71
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aeb6a
leaq 0x8d2d0(%rip), %rax     # 0x23be38
jmp 0x1aeb71
leaq 0xf5ba3(%rip), %rax     # 0x2a4714
movq %rax, 0x58c7b0(%rip)    # 0x73b328
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_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 0x5672cf
testl %eax, %eax
je 0x1aebcb
leaq 0x2f70b7(%rip), %rax    # 0x4a5c80
jmp 0x1aebfa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aebdf
leaq 0x1fd4f7(%rip), %rax    # 0x3ac0d4
jmp 0x1aebfa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aebf3
leaq 0x8d247(%rip), %rax     # 0x23be38
jmp 0x1aebfa
leaq 0xf7c8e(%rip), %rax     # 0x2a6888
movq %rax, 0x58c72f(%rip)    # 0x73b330
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_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 0x5672cf
testl %eax, %eax
je 0x1aec54
leaq 0x2fae82(%rip), %rax    # 0x4a9ad4
jmp 0x1aec83
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aec68
leaq 0x1ffe26(%rip), %rax    # 0x3aea8c
jmp 0x1aec83
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aec7c
leaq 0x8d1be(%rip), %rax     # 0x23be38
jmp 0x1aec83
leaq 0xfa941(%rip), %rax     # 0x2a95c4
movq %rax, 0x58c6ae(%rip)    # 0x73b338
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_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 0x5672cf
testl %eax, %eax
je 0x1aecdd
leaq 0x30a805(%rip), %rax    # 0x4b94e0
jmp 0x1aed0c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aecf1
leaq 0x20cba9(%rip), %rax    # 0x3bb898
jmp 0x1aed0c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aed05
leaq 0x8e0f9(%rip), %rax     # 0x23cdfc
jmp 0x1aed0c
leaq 0x108230(%rip), %rax    # 0x2b6f3c
movq %rax, 0x58c62d(%rip)    # 0x73b340
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_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 0x5672cf
testl %eax, %eax
je 0x1aed66
leaq 0x30ee94(%rip), %rax    # 0x4bdbf8
jmp 0x1aed95
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aed7a
leaq 0x210e20(%rip), %rax    # 0x3bfb98
jmp 0x1aed95
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aed8e
leaq 0x8e070(%rip), %rax     # 0x23cdfc
jmp 0x1aed95
leaq 0x10d303(%rip), %rax    # 0x2bc098
movq %rax, 0x58c5ac(%rip)    # 0x73b348
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_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 0x5672cf
testl %eax, %eax
je 0x1aedef
leaq 0x3128ef(%rip), %rax    # 0x4c16dc
jmp 0x1aee1e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aee03
leaq 0x21462b(%rip), %rax    # 0x3c342c
jmp 0x1aee1e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aee17
leaq 0x8dfe7(%rip), %rax     # 0x23cdfc
jmp 0x1aee1e
leaq 0x1111ca(%rip), %rax    # 0x2bffe8
movq %rax, 0x58c52b(%rip)    # 0x73b350
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_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 0x5672cf
testl %eax, %eax
je 0x1aee78
leaq 0x3167b2(%rip), %rax    # 0x4c5628
jmp 0x1aeea7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aee8c
leaq 0x21812e(%rip), %rax    # 0x3c6fb8
jmp 0x1aeea7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aeea0
leaq 0x8df5e(%rip), %rax     # 0x23cdfc
jmp 0x1aeea7
leaq 0x115031(%rip), %rax    # 0x2c3ed8
movq %rax, 0x58c4aa(%rip)    # 0x73b358
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_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 0x5672cf
testl %eax, %eax
je 0x1aef01
leaq 0x32fe1d(%rip), %rax    # 0x4ded1c
jmp 0x1aef30
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aef15
leaq 0x22d69d(%rip), %rax    # 0x3dc5b0
jmp 0x1aef30
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aef29
leaq 0x8cf11(%rip), %rax     # 0x23be38
jmp 0x1aef30
leaq 0x12ce50(%rip), %rax    # 0x2dbd80
movq %rax, 0x58c429(%rip)    # 0x73b360
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_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 0x5672cf
testl %eax, %eax
je 0x1aef8a
leaq 0x333fbc(%rip), %rax    # 0x4e2f44
jmp 0x1aefb9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1aef9e
leaq 0x2315a8(%rip), %rax    # 0x3e0544
jmp 0x1aefb9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1aefb2
leaq 0x8ce88(%rip), %rax     # 0x23be38
jmp 0x1aefb9
leaq 0x131b83(%rip), %rax    # 0x2e0b3c
movq %rax, 0x58c3a8(%rip)    # 0x73b368
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_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 0x5672cf
testl %eax, %eax
je 0x1af013
leaq 0x337d2f(%rip), %rax    # 0x4e6d40
jmp 0x1af042
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af027
leaq 0x2350df(%rip), %rax    # 0x3e4104
jmp 0x1af042
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af03b
leaq 0x8cdff(%rip), %rax     # 0x23be38
jmp 0x1af042
leaq 0x135ce2(%rip), %rax    # 0x2e4d24
movq %rax, 0x58c327(%rip)    # 0x73b370
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_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 0x5672cf
testl %eax, %eax
je 0x1af09c
leaq 0x33c036(%rip), %rax    # 0x4eb0d0
jmp 0x1af0cb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af0b0
leaq 0x239022(%rip), %rax    # 0x3e80d0
jmp 0x1af0cb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af0c4
leaq 0x8cd76(%rip), %rax     # 0x23be38
jmp 0x1af0cb
leaq 0x139e49(%rip), %rax    # 0x2e8f14
movq %rax, 0x58c2a6(%rip)    # 0x73b378
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_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 0x5672cf
testl %eax, %eax
je 0x1af125
leaq 0x31aad1(%rip), %rax    # 0x4c9bf4
jmp 0x1af154
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af139
leaq 0x21bd71(%rip), %rax    # 0x3caea8
jmp 0x1af154
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af14d
leaq 0x8cced(%rip), %rax     # 0x23be38
jmp 0x1af154
leaq 0x1192a0(%rip), %rax    # 0x2c83f4
movq %rax, 0x58c225(%rip)    # 0x73b380
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_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 0x5672cf
testl %eax, %eax
je 0x1af1ae
leaq 0x31eaa4(%rip), %rax    # 0x4cdc50
jmp 0x1af1dd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af1c2
leaq 0x21fb9c(%rip), %rax    # 0x3ced5c
jmp 0x1af1dd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af1d6
leaq 0x8cc64(%rip), %rax     # 0x23be38
jmp 0x1af1dd
leaq 0x11dc3f(%rip), %rax    # 0x2cce1c
movq %rax, 0x58c1a4(%rip)    # 0x73b388
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_table_diag_16_dispatcher
parasail_result_t* parasail_nw_stats_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_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_stats_table_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_stats_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 0x5672cf
testl %eax, %eax
je 0x1af237
leaq 0x322b37(%rip), %rax    # 0x4d1d6c
jmp 0x1af266
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af24b
leaq 0x2234df(%rip), %rax    # 0x3d2728
jmp 0x1af266
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af25f
leaq 0x8cbdb(%rip), %rax     # 0x23be38
jmp 0x1af266
leaq 0x121b3e(%rip), %rax    # 0x2d0da4
movq %rax, 0x58c123(%rip)    # 0x73b390
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_table_diag_8_dispatcher
parasail_result_t* parasail_nw_stats_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_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_stats_table_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_stats_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 0x5672cf
testl %eax, %eax
je 0x1af2c0
leaq 0x328222(%rip), %rax    # 0x4d74e0
jmp 0x1af2ef
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af2d4
leaq 0x22789e(%rip), %rax    # 0x3d6b70
jmp 0x1af2ef
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af2e8
leaq 0x8cb52(%rip), %rax     # 0x23be38
jmp 0x1af2ef
leaq 0x1262e5(%rip), %rax    # 0x2d55d4
movq %rax, 0x58c0a2(%rip)    # 0x73b398
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_rowcol_scan_64_dispatcher
parasail_result_t* parasail_nw_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af349
leaq 0x340765(%rip), %rax    # 0x4efaac
jmp 0x1af378
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af35d
leaq 0x23d09d(%rip), %rax    # 0x3ec3f8
jmp 0x1af378
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af371
leaq 0x8da8d(%rip), %rax     # 0x23cdfc
jmp 0x1af378
leaq 0x13e3dc(%rip), %rax    # 0x2ed754
movq %rax, 0x58c021(%rip)    # 0x73b3a0
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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_nw_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af3d2
leaq 0x342a8c(%rip), %rax    # 0x4f1e5c
jmp 0x1af401
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af3e6
leaq 0x23ef5c(%rip), %rax    # 0x3ee340
jmp 0x1af401
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af3fa
leaq 0x8da04(%rip), %rax     # 0x23cdfc
jmp 0x1af401
leaq 0x140a47(%rip), %rax    # 0x2efe48
movq %rax, 0x58bfa0(%rip)    # 0x73b3a8
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_rowcol_scan_16_dispatcher
parasail_result_t* parasail_nw_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af45b
leaq 0x34480b(%rip), %rax    # 0x4f3c64
jmp 0x1af48a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af46f
leaq 0x240b7f(%rip), %rax    # 0x3effec
jmp 0x1af48a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af483
leaq 0x8d97b(%rip), %rax     # 0x23cdfc
jmp 0x1af48a
leaq 0x1429fa(%rip), %rax    # 0x2f1e84
movq %rax, 0x58bf1f(%rip)    # 0x73b3b0
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_rowcol_scan_8_dispatcher
parasail_result_t* parasail_nw_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_rowcol_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af4e4
leaq 0x3469e6(%rip), %rax    # 0x4f5ec8
jmp 0x1af513
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af4f8
leaq 0x242a2e(%rip), %rax    # 0x3f1f24
jmp 0x1af513
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af50c
leaq 0x8d8f2(%rip), %rax     # 0x23cdfc
jmp 0x1af513
leaq 0x144925(%rip), %rax    # 0x2f3e38
movq %rax, 0x58be9e(%rip)    # 0x73b3b8
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_rowcol_striped_64_dispatcher
parasail_result_t* parasail_nw_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af56d
leaq 0x358ce1(%rip), %rax    # 0x50824c
jmp 0x1af59c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af581
leaq 0x24f4c1(%rip), %rax    # 0x3fea40
jmp 0x1af59c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af595
leaq 0x8c8a5(%rip), %rax     # 0x23be38
jmp 0x1af59c
leaq 0x152e8c(%rip), %rax    # 0x302428
movq %rax, 0x58be1d(%rip)    # 0x73b3c0
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_rowcol_striped_32_dispatcher
parasail_result_t* parasail_nw_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_rowcol_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1af5f6
leaq 0x35ade8(%rip), %rax    # 0x50a3dc
jmp 0x1af625
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1af60a
leaq 0x251488(%rip), %rax    # 0x400a90
jmp 0x1af625
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1af61e
leaq 0x8c81c(%rip), %rax     # 0x23be38
jmp 0x1af625
leaq 0x15557b(%rip), %rax    # 0x304ba0
movq %rax, 0x58bd9c(%rip)    # 0x73b3c8
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