LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_8_pointer = parasail_sw_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2152b4
leaq 0x2a2fa6(%rip), %rax    # 0x4b8258
jmp 0x2152e3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2152c8
leaq 0x1b95ee(%rip), %rax    # 0x3ce8b4
jmp 0x2152e3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2152dc
leaq 0x8491a(%rip), %rax     # 0x299bf4
jmp 0x2152e3
leaq 0xc6939(%rip), %rax     # 0x2dbc1c
movq %rax, 0x58d8ae(%rip)    # 0x7a2b98
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_64_pointer = parasail_sw_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21533d
leaq 0x2b3869(%rip), %rax    # 0x4c8ba4
jmp 0x21536c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215351
leaq 0x1c7931(%rip), %rax    # 0x3dcc80
jmp 0x21536c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215365
leaq 0x8570d(%rip), %rax     # 0x29aa70
jmp 0x21536c
leaq 0xd7580(%rip), %rax     # 0x2ec8ec
movq %rax, 0x58d82d(%rip)    # 0x7a2ba0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_32_pointer = parasail_sw_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2153c6
leaq 0x2b577c(%rip), %rax    # 0x4cab40
jmp 0x2153f5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2153da
leaq 0x1c922c(%rip), %rax    # 0x3de604
jmp 0x2153f5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2153ee
leaq 0x85684(%rip), %rax     # 0x29aa70
jmp 0x2153f5
leaq 0xd90db(%rip), %rax     # 0x2ee4d0
movq %rax, 0x58d7ac(%rip)    # 0x7a2ba8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_16_pointer = parasail_sw_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21544f
leaq 0x2b758f(%rip), %rax    # 0x4cc9dc
jmp 0x21547e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215463
leaq 0x1cac63(%rip), %rax    # 0x3e00c4
jmp 0x21547e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215477
leaq 0x855fb(%rip), %rax     # 0x29aa70
jmp 0x21547e
leaq 0xdac22(%rip), %rax     # 0x2f00a0
movq %rax, 0x58d72b(%rip)    # 0x7a2bb0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_8_pointer = parasail_sw_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2154d8
leaq 0x2b98ae(%rip), %rax    # 0x4ced84
jmp 0x215507
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2154ec
leaq 0x1cca9e(%rip), %rax    # 0x3e1f88
jmp 0x215507
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215500
leaq 0x85572(%rip), %rax     # 0x29aa70
jmp 0x215507
leaq 0xdcd61(%rip), %rax     # 0x2f2268
movq %rax, 0x58d6aa(%rip)    # 0x7a2bb8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_64_pointer = parasail_sw_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x215561
leaq 0x2cabfd(%rip), %rax    # 0x4e015c
jmp 0x215590
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215575
leaq 0x1d874d(%rip), %rax    # 0x3edcc0
jmp 0x215590
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215589
leaq 0x8466d(%rip), %rax     # 0x299bf4
jmp 0x215590
leaq 0xe9a94(%rip), %rax     # 0x2ff024
movq %rax, 0x58d629(%rip)    # 0x7a2bc0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_32_pointer = parasail_sw_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2155ea
leaq 0x2cc754(%rip), %rax    # 0x4e1d3c
jmp 0x215619
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2155fe
leaq 0x1d9ee8(%rip), %rax    # 0x3ef4e4
jmp 0x215619
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215612
leaq 0x845e4(%rip), %rax     # 0x299bf4
jmp 0x215619
leaq 0xeb47f(%rip), %rax     # 0x300a98
movq %rax, 0x58d5a8(%rip)    # 0x7a2bc8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_16_pointer = parasail_sw_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x215673
leaq 0x2ce6bf(%rip), %rax    # 0x4e3d30
jmp 0x2156a2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215687
leaq 0x1db7cb(%rip), %rax    # 0x3f0e50
jmp 0x2156a2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21569b
leaq 0x8455b(%rip), %rax     # 0x299bf4
jmp 0x2156a2
leaq 0xece26(%rip), %rax     # 0x3024c8
movq %rax, 0x58d527(%rip)    # 0x7a2bd0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_8_pointer = parasail_sw_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2156fc
leaq 0x2d0cca(%rip), %rax    # 0x4e63c4
jmp 0x21572b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215710
leaq 0x1dd71a(%rip), %rax    # 0x3f2e28
jmp 0x21572b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215724
leaq 0x844d2(%rip), %rax     # 0x299bf4
jmp 0x21572b
leaq 0xef13d(%rip), %rax     # 0x304868
movq %rax, 0x58d4a6(%rip)    # 0x7a2bd8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_64_pointer = parasail_sw_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x215785
leaq 0x2bbd19(%rip), %rax    # 0x4d149c
jmp 0x2157b4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215799
leaq 0x1ce5d1(%rip), %rax    # 0x3e3d68
jmp 0x2157b4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2157ad
leaq 0x84449(%rip), %rax     # 0x299bf4
jmp 0x2157b4
leaq 0xdec80(%rip), %rax     # 0x2f4434
movq %rax, 0x58d425(%rip)    # 0x7a2be0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_32_pointer = parasail_sw_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21580e
leaq 0x2be454(%rip), %rax    # 0x4d3c60
jmp 0x21583d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215822
leaq 0x1d02c0(%rip), %rax    # 0x3e5ae0
jmp 0x21583d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215836
leaq 0x843c0(%rip), %rax     # 0x299bf4
jmp 0x21583d
leaq 0xe0cff(%rip), %rax     # 0x2f653c
movq %rax, 0x58d3a4(%rip)    # 0x7a2be8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_16_pointer = parasail_sw_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x215897
leaq 0x2c184f(%rip), %rax    # 0x4d70e4
jmp 0x2158c6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2158ab
leaq 0x1d2673(%rip), %rax    # 0x3e7f1c
jmp 0x2158c6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2158bf
leaq 0x84337(%rip), %rax     # 0x299bf4
jmp 0x2158c6
leaq 0xe335a(%rip), %rax     # 0x2f8c20
movq %rax, 0x58d323(%rip)    # 0x7a2bf0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_8_pointer = parasail_sw_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215920
leaq 0x2c6d06(%rip), %rax    # 0x4dc624
jmp 0x21594f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215934
leaq 0x1d5a32(%rip), %rax    # 0x3eb364
jmp 0x21594f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215948
leaq 0x842ae(%rip), %rax     # 0x299bf4
jmp 0x21594f
leaq 0xe6b59(%rip), %rax     # 0x2fc4a8
movq %rax, 0x58d2a2(%rip)    # 0x7a2bf8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x2159a9
leaq 0x2d46a5(%rip), %rax    # 0x4ea04c
jmp 0x2159d8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2159bd
leaq 0x1e0e65(%rip), %rax    # 0x3f6820
jmp 0x2159d8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2159d1
leaq 0x850a1(%rip), %rax     # 0x29aa70
jmp 0x2159d8
leaq 0xf2530(%rip), %rax     # 0x307f08
movq %rax, 0x58d221(%rip)    # 0x7a2c00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215a32
leaq 0x2d8178(%rip), %rax    # 0x4edba8
jmp 0x215a61
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215a46
leaq 0x1e42fc(%rip), %rax    # 0x3f9d40
jmp 0x215a61
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215a5a
leaq 0x85018(%rip), %rax     # 0x29aa70
jmp 0x215a61
leaq 0xf5fb3(%rip), %rax     # 0x30ba14
movq %rax, 0x58d1a0(%rip)    # 0x7a2c08
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215abb
leaq 0x2dbf43(%rip), %rax    # 0x4f19fc
jmp 0x215aea
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215acf
leaq 0x1e79f3(%rip), %rax    # 0x3fd4c0
jmp 0x215aea
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215ae3
leaq 0x84f8f(%rip), %rax     # 0x29aa70
jmp 0x215aea
leaq 0xf9b0a(%rip), %rax     # 0x30f5f4
movq %rax, 0x58d11f(%rip)    # 0x7a2c10
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215b44
leaq 0x2e0192(%rip), %rax    # 0x4f5cd4
jmp 0x215b73
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215b58
leaq 0x1eb952(%rip), %rax    # 0x4014a8
jmp 0x215b73
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215b6c
leaq 0x84f06(%rip), %rax     # 0x29aa70
jmp 0x215b73
leaq 0xfdfc5(%rip), %rax     # 0x313b38
movq %rax, 0x58d09e(%rip)    # 0x7a2c18
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215bcd
leaq 0x2fac99(%rip), %rax    # 0x510864
jmp 0x215bfc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215be1
leaq 0x2007f5(%rip), %rax    # 0x4163d4
jmp 0x215bfc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215bf5
leaq 0x84001(%rip), %rax     # 0x299bf4
jmp 0x215bfc
leaq 0x114b8c(%rip), %rax    # 0x32a788
movq %rax, 0x58d01d(%rip)    # 0x7a2c20
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215c56
leaq 0x2fe544(%rip), %rax    # 0x514198
jmp 0x215c85
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215c6a
leaq 0x203a98(%rip), %rax    # 0x419700
jmp 0x215c85
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215c7e
leaq 0x83f78(%rip), %rax     # 0x299bf4
jmp 0x215c85
leaq 0x1184ef(%rip), %rax    # 0x32e174
movq %rax, 0x58cf9c(%rip)    # 0x7a2c28
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215cdf
leaq 0x302bef(%rip), %rax    # 0x5188cc
jmp 0x215d0e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215cf3
leaq 0x2073ff(%rip), %rax    # 0x41d0f0
jmp 0x215d0e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215d07
leaq 0x83eef(%rip), %rax     # 0x299bf4
jmp 0x215d0e
leaq 0x11c17a(%rip), %rax    # 0x331e88
movq %rax, 0x58cf1b(%rip)    # 0x7a2c30
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215d68
leaq 0x307662(%rip), %rax    # 0x51d3c8
jmp 0x215d97
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215d7c
leaq 0x20c0ea(%rip), %rax    # 0x421e64
jmp 0x215d97
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215d90
leaq 0x83e66(%rip), %rax     # 0x299bf4
jmp 0x215d97
leaq 0x121231(%rip), %rax    # 0x336fc8
movq %rax, 0x58ce9a(%rip)    # 0x7a2c38
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x594f9c
testl %eax, %eax
je 0x215df1
leaq 0x2e443d(%rip), %rax    # 0x4fa22c
jmp 0x215e20
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x215e05
leaq 0x1ef331(%rip), %rax    # 0x405134
jmp 0x215e20
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x215e19
leaq 0x83ddd(%rip), %rax     # 0x299bf4
jmp 0x215e20
leaq 0x102088(%rip), %rax    # 0x317ea8
movq %rax, 0x58ce19(%rip)    # 0x7a2c40
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