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_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_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_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_rowcol_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 0x216a40
leaq 0x35cd26(%rip), %rax    # 0x573764
jmp 0x216a6f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216a54
leaq 0x252bea(%rip), %rax    # 0x46963c
jmp 0x216a6f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216a68
leaq 0x8318e(%rip), %rax     # 0x299bf4
jmp 0x216a6f
leaq 0x16d2b9(%rip), %rax    # 0x383d28
movq %rax, 0x58c282(%rip)    # 0x7a2cf8
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_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_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_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_rowcol_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 0x216ac9
leaq 0x33b7b9(%rip), %rax    # 0x552280
jmp 0x216af8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216add
leaq 0x236bad(%rip), %rax    # 0x44d688
jmp 0x216af8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216af1
leaq 0x83105(%rip), %rax     # 0x299bf4
jmp 0x216af8
leaq 0x14ee54(%rip), %rax    # 0x36594c
movq %rax, 0x58c201(%rip)    # 0x7a2d00
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_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_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_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_rowcol_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 0x216b52
leaq 0x33fd64(%rip), %rax    # 0x5568b4
jmp 0x216b81
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216b66
leaq 0x23a9a4(%rip), %rax    # 0x451508
jmp 0x216b81
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216b7a
leaq 0x8307c(%rip), %rax     # 0x299bf4
jmp 0x216b81
leaq 0x15314b(%rip), %rax    # 0x369ccc
movq %rax, 0x58c180(%rip)    # 0x7a2d08
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_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_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_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_rowcol_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 0x216bdb
leaq 0x344eef(%rip), %rax    # 0x55bac8
jmp 0x216c0a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216bef
leaq 0x23ed63(%rip), %rax    # 0x455950
jmp 0x216c0a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216c03
leaq 0x82ff3(%rip), %rax     # 0x299bf4
jmp 0x216c0a
leaq 0x157752(%rip), %rax    # 0x36e35c
movq %rax, 0x58c0ff(%rip)    # 0x7a2d10
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_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_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_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_rowcol_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 0x216c64
leaq 0x34c372(%rip), %rax    # 0x562fd4
jmp 0x216c93
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216c78
leaq 0x244086(%rip), %rax    # 0x45acfc
jmp 0x216c93
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216c8c
leaq 0x82f6a(%rip), %rax     # 0x299bf4
jmp 0x216c93
leaq 0x15d101(%rip), %rax    # 0x373d94
movq %rax, 0x58c07e(%rip)    # 0x7a2d18
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_trace_scan_64_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_scan_64_pointer = parasail_sw_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x216ced
leaq 0x35fd2d(%rip), %rax    # 0x576a18
jmp 0x216d1c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216d01
leaq 0x2555cd(%rip), %rax    # 0x46c2cc
jmp 0x216d1c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216d15
leaq 0x83d5d(%rip), %rax     # 0x29aa70
jmp 0x216d1c
leaq 0x170014(%rip), %rax    # 0x386d30
movq %rax, 0x58bffd(%rip)    # 0x7a2d20
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_trace_scan_32_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_scan_32_pointer = parasail_sw_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x216d76
leaq 0x361c2c(%rip), %rax    # 0x5789a0
jmp 0x216da5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216d8a
leaq 0x257110(%rip), %rax    # 0x46de98
jmp 0x216da5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216d9e
leaq 0x83cd4(%rip), %rax     # 0x29aa70
jmp 0x216da5
leaq 0x171e33(%rip), %rax    # 0x388bd8
movq %rax, 0x58bf7c(%rip)    # 0x7a2d28
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_trace_scan_16_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_scan_16_pointer = parasail_sw_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x216dff
leaq 0x363663(%rip), %rax    # 0x57a460
jmp 0x216e2e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216e13
leaq 0x258aaf(%rip), %rax    # 0x46f8c0
jmp 0x216e2e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216e27
leaq 0x83c4b(%rip), %rax     # 0x29aa70
jmp 0x216e2e
leaq 0x17395e(%rip), %rax    # 0x38a78c
movq %rax, 0x58befb(%rip)    # 0x7a2d30
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_trace_scan_8_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_scan_8_pointer = parasail_sw_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_trace_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x216e88
leaq 0x36507a(%rip), %rax    # 0x57bf00
jmp 0x216eb7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216e9c
leaq 0x25a47a(%rip), %rax    # 0x471314
jmp 0x216eb7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216eb0
leaq 0x83bc2(%rip), %rax     # 0x29aa70
jmp 0x216eb7
leaq 0x1755e5(%rip), %rax    # 0x38c49c
movq %rax, 0x58be7a(%rip)    # 0x7a2d38
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_trace_striped_64_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_64_pointer = parasail_sw_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x216f11
leaq 0x376d51(%rip), %rax    # 0x58dc60
jmp 0x216f40
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216f25
leaq 0x266e3d(%rip), %rax    # 0x47dd60
jmp 0x216f40
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216f39
leaq 0x82cbd(%rip), %rax     # 0x299bf4
jmp 0x216f40
leaq 0x183458(%rip), %rax    # 0x39a398
movq %rax, 0x58bdf9(%rip)    # 0x7a2d40
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_trace_striped_32_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_32_pointer = parasail_sw_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x216f9a
leaq 0x37929c(%rip), %rax    # 0x590234
jmp 0x216fc9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x216fae
leaq 0x269170(%rip), %rax    # 0x48011c
jmp 0x216fc9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x216fc2
leaq 0x82c34(%rip), %rax     # 0x299bf4
jmp 0x216fc9
leaq 0x185b37(%rip), %rax    # 0x39cb00
movq %rax, 0x58bd78(%rip)    # 0x7a2d48
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_trace_striped_16_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_16_pointer = parasail_sw_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x217023
leaq 0x37b37b(%rip), %rax    # 0x59239c
jmp 0x217052
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217037
leaq 0x26b1ef(%rip), %rax    # 0x482224
jmp 0x217052
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21704b
leaq 0x82bab(%rip), %rax     # 0x299bf4
jmp 0x217052
leaq 0x187cfe(%rip), %rax    # 0x39ed50
movq %rax, 0x58bcf7(%rip)    # 0x7a2d50
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_trace_striped_8_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_8_pointer = parasail_sw_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_trace_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x2170ac
leaq 0x37d48a(%rip), %rax    # 0x594534
jmp 0x2170db
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2170c0
leaq 0x26d27e(%rip), %rax    # 0x48433c
jmp 0x2170db
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2170d4
leaq 0x82b22(%rip), %rax     # 0x299bf4
jmp 0x2170db
leaq 0x18a0c1(%rip), %rax    # 0x3a119c
movq %rax, 0x58bc76(%rip)    # 0x7a2d58
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_trace_diag_64_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_64_pointer = parasail_sw_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x217135
leaq 0x367325(%rip), %rax    # 0x57e458
jmp 0x217164
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217149
leaq 0x25c031(%rip), %rax    # 0x473178
jmp 0x217164
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21715d
leaq 0x82a99(%rip), %rax     # 0x299bf4
jmp 0x217164
leaq 0x1776a0(%rip), %rax    # 0x38e804
movq %rax, 0x58bbf5(%rip)    # 0x7a2d60
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_trace_diag_32_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_32_pointer = parasail_sw_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x2171be
leaq 0x369c98(%rip), %rax    # 0x580e54
jmp 0x2171ed
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2171d2
leaq 0x25df8c(%rip), %rax    # 0x47515c
jmp 0x2171ed
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2171e6
leaq 0x82a10(%rip), %rax     # 0x299bf4
jmp 0x2171ed
leaq 0x17999b(%rip), %rax    # 0x390b88
movq %rax, 0x58bb74(%rip)    # 0x7a2d68
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_trace_diag_16_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_16_pointer = parasail_sw_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x217247
leaq 0x36d1ff(%rip), %rax    # 0x584444
jmp 0x217276
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21725b
leaq 0x260447(%rip), %rax    # 0x4776a0
jmp 0x217276
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21726f
leaq 0x82987(%rip), %rax     # 0x299bf4
jmp 0x217276
leaq 0x17c09e(%rip), %rax    # 0x393314
movq %rax, 0x58baf3(%rip)    # 0x7a2d70
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_trace_diag_8_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_8_pointer = parasail_sw_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_trace_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x2172d0
leaq 0x37267e(%rip), %rax    # 0x58994c
jmp 0x2172ff
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2172e4
leaq 0x26381a(%rip), %rax    # 0x47aafc
jmp 0x2172ff
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2172f8
leaq 0x828fe(%rip), %rax     # 0x299bf4
jmp 0x2172ff
leaq 0x17f9cd(%rip), %rax    # 0x396ccc
movq %rax, 0x58ba72(%rip)    # 0x7a2d78
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_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x217352
leaq 0x26f4be(%rip), %rax    # 0x48680e
jmp 0x217378
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x217366
leaq 0x18bca2(%rip), %rax    # 0x3a3006
jmp 0x217378
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217397
leaq 0x94e82(%rip), %rax     # 0x2ac1fa
movq %rax, 0x58ba01(%rip)    # 0x7a2d80
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2173cc
leaq 0x270f8c(%rip), %rax    # 0x488356
jmp 0x2173f2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2173e0
leaq 0x18d450(%rip), %rax    # 0x3a482e
jmp 0x2173f2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217411
leaq 0x96870(%rip), %rax     # 0x2adc62
movq %rax, 0x58b98f(%rip)    # 0x7a2d88
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x217446
leaq 0x272602(%rip), %rax    # 0x489a46
jmp 0x21746c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21745a
leaq 0x18eaaa(%rip), %rax    # 0x3a5f02
jmp 0x21746c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21748b
leaq 0x97fce(%rip), %rax     # 0x2af43a
movq %rax, 0x58b91d(%rip)    # 0x7a2d90
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2174c0
leaq 0x273c4c(%rip), %rax    # 0x48b10a
jmp 0x2174e6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2174d4
leaq 0x1900f4(%rip), %rax    # 0x3a75c6
jmp 0x2174e6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x217505
leaq 0x998e0(%rip), %rax     # 0x2b0dc6
movq %rax, 0x58b8ab(%rip)    # 0x7a2d98
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21753a
leaq 0x2802d6(%rip), %rax    # 0x49780e
jmp 0x217560
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21754e
leaq 0x1996ba(%rip), %rax    # 0x3b0c06
jmp 0x217560
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x21757f
leaq 0xa3d46(%rip), %rax     # 0x2bb2a6
movq %rax, 0x58b839(%rip)    # 0x7a2da0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2175b4
leaq 0x281a1c(%rip), %rax    # 0x498fce
jmp 0x2175da
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2175c8
leaq 0x19ac7c(%rip), %rax    # 0x3b2242
jmp 0x2175da
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2175f9
leaq 0xa5498(%rip), %rax     # 0x2bca72
movq %rax, 0x58b7c7(%rip)    # 0x7a2da8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq