LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_64_dispatcher
parasail_result_t* parasail_sw_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2162c9
leaq 0x2b1fed(%rip), %rax    # 0x4c82b4
jmp 0x2162f8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2162dd
leaq 0x1c2455(%rip), %rax    # 0x3d8730
jmp 0x2162f8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2162f1
leaq 0x861cd(%rip), %rax     # 0x29c4bc
jmp 0x2162f8
leaq 0xb3b98(%rip), %rax     # 0x2c9e90
movq %rax, 0x5c2841(%rip)    # 0x7d8b40
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_32_dispatcher
parasail_result_t* parasail_sw_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x216352
leaq 0x2b4ef0(%rip), %rax    # 0x4cb240
jmp 0x216381
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216366
leaq 0x1c5480(%rip), %rax    # 0x3db7e4
jmp 0x216381
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21637a
leaq 0x86144(%rip), %rax     # 0x29c4bc
jmp 0x216381
leaq 0xb743b(%rip), %rax     # 0x2cd7bc
movq %rax, 0x5c27c0(%rip)    # 0x7d8b48
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_16_dispatcher
parasail_result_t* parasail_sw_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2163db
leaq 0x2b8633(%rip), %rax    # 0x4cea0c
jmp 0x21640a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2163ef
leaq 0x1c8843(%rip), %rax    # 0x3dec30
jmp 0x21640a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216403
leaq 0x860bb(%rip), %rax     # 0x29c4bc
jmp 0x21640a
leaq 0xbafe6(%rip), %rax     # 0x2d13f0
movq %rax, 0x5c273f(%rip)    # 0x7d8b50
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_8_dispatcher
parasail_result_t* parasail_sw_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x216464
leaq 0x2bc8a6(%rip), %rax    # 0x4d2d08
jmp 0x216493
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216478
leaq 0x1cc042(%rip), %rax    # 0x3e24b8
jmp 0x216493
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21648c
leaq 0x86032(%rip), %rax     # 0x29c4bc
jmp 0x216493
leaq 0xbf4e1(%rip), %rax     # 0x2d5974
movq %rax, 0x5c26be(%rip)    # 0x7d8b58
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_64_dispatcher
parasail_result_t* parasail_sw_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2164ed
leaq 0x2cf8cd(%rip), %rax    # 0x4e5db8
jmp 0x21651c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216501
leaq 0x1dcff5(%rip), %rax    # 0x3f34f4
jmp 0x21651c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216515
leaq 0x84cad(%rip), %rax     # 0x29b1c0
jmp 0x21651c
leaq 0xd3708(%rip), %rax     # 0x2e9c24
movq %rax, 0x5c263d(%rip)    # 0x7d8b60
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_32_dispatcher
parasail_result_t* parasail_sw_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x216576
leaq 0x2d2580(%rip), %rax    # 0x4e8af4
jmp 0x2165a5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21658a
leaq 0x1dfdec(%rip), %rax    # 0x3f6374
jmp 0x2165a5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21659e
leaq 0x84c24(%rip), %rax     # 0x29b1c0
jmp 0x2165a5
leaq 0xd703f(%rip), %rax     # 0x2ed5e4
movq %rax, 0x5c25bc(%rip)    # 0x7d8b68
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_16_dispatcher
parasail_result_t* parasail_sw_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2165ff
leaq 0x2d5c8b(%rip), %rax    # 0x4ec288
jmp 0x21662e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216613
leaq 0x1e2f73(%rip), %rax    # 0x3f9584
jmp 0x21662e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216627
leaq 0x84b9b(%rip), %rax     # 0x29b1c0
jmp 0x21662e
leaq 0xda6ea(%rip), %rax     # 0x2f0d18
movq %rax, 0x5c253b(%rip)    # 0x7d8b70
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_8_dispatcher
parasail_result_t* parasail_sw_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x216688
leaq 0x2da31a(%rip), %rax    # 0x4f09a0
jmp 0x2166b7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21669c
leaq 0x1e64ea(%rip), %rax    # 0x3fcb84
jmp 0x2166b7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2166b0
leaq 0x84b12(%rip), %rax     # 0x29b1c0
jmp 0x2166b7
leaq 0xde789(%rip), %rax     # 0x2f4e40
movq %rax, 0x5c24ba(%rip)    # 0x7d8b78
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_64_dispatcher
parasail_result_t* parasail_sw_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x216711
leaq 0x2bf8ad(%rip), %rax    # 0x4d5fbc
jmp 0x216740
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216725
leaq 0x1ceed5(%rip), %rax    # 0x3e55f8
jmp 0x216740
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216739
leaq 0x84a89(%rip), %rax     # 0x29b1c0
jmp 0x216740
leaq 0xc2ec8(%rip), %rax     # 0x2d9608
movq %rax, 0x5c2439(%rip)    # 0x7d8b80
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_32_dispatcher
parasail_result_t* parasail_sw_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21679a
leaq 0x2c2e24(%rip), %rax    # 0x4d95bc
jmp 0x2167c9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2167ae
leaq 0x1d1fb4(%rip), %rax    # 0x3e8760
jmp 0x2167c9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2167c2
leaq 0x84a00(%rip), %rax     # 0x29b1c0
jmp 0x2167c9
leaq 0xc68cf(%rip), %rax     # 0x2dd098
movq %rax, 0x5c23b8(%rip)    # 0x7d8b88
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_16_dispatcher
parasail_result_t* parasail_sw_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x216823
leaq 0x2c6d6f(%rip), %rax    # 0x4dd590
jmp 0x216852
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216837
leaq 0x1d5633(%rip), %rax    # 0x3ebe68
jmp 0x216852
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21684b
leaq 0x84977(%rip), %rax     # 0x29b1c0
jmp 0x216852
leaq 0xca262(%rip), %rax     # 0x2e0ab4
movq %rax, 0x5c2337(%rip)    # 0x7d8b90
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x2168ac
leaq 0x2cbafa(%rip), %rax    # 0x4e23a4
jmp 0x2168db
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2168c0
leaq 0x1d9646(%rip), %rax    # 0x3eff04
jmp 0x2168db
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2168d4
leaq 0x848ee(%rip), %rax     # 0x29b1c0
jmp 0x2168db
leaq 0xcee09(%rip), %rax     # 0x2e56e4
movq %rax, 0x5c22b6(%rip)    # 0x7d8b98
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216935
leaq 0x2dd4f1(%rip), %rax    # 0x4f3e24
jmp 0x216964
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216949
leaq 0x1e84a9(%rip), %rax    # 0x3fedf0
jmp 0x216964
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21695d
leaq 0x85b61(%rip), %rax     # 0x29c4bc
jmp 0x216964
leaq 0xe2014(%rip), %rax     # 0x2f8978
movq %rax, 0x5c2235(%rip)    # 0x7d8ba0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x2169be
leaq 0x2df128(%rip), %rax    # 0x4f5ae4
jmp 0x2169ed
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2169d2
leaq 0x1e9fb4(%rip), %rax    # 0x400984
jmp 0x2169ed
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2169e6
leaq 0x85ad8(%rip), %rax     # 0x29c4bc
jmp 0x2169ed
leaq 0xe3fe7(%rip), %rax     # 0x2fa9d4
movq %rax, 0x5c21b4(%rip)    # 0x7d8ba8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216a47
leaq 0x2e1c7f(%rip), %rax    # 0x4f86c4
jmp 0x216a76
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216a5b
leaq 0x1ebf6f(%rip), %rax    # 0x4029c8
jmp 0x216a76
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216a6f
leaq 0x85a4f(%rip), %rax     # 0x29c4bc
jmp 0x216a76
leaq 0xe63f2(%rip), %rax     # 0x2fce68
movq %rax, 0x5c2133(%rip)    # 0x7d8bb0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216ad0
leaq 0x2e5a92(%rip), %rax    # 0x4fc560
jmp 0x216aff
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216ae4
leaq 0x1ee6de(%rip), %rax    # 0x4051c0
jmp 0x216aff
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216af8
leaq 0x859c6(%rip), %rax     # 0x29c4bc
jmp 0x216aff
leaq 0xe94b1(%rip), %rax     # 0x2fffb0
movq %rax, 0x5c20b2(%rip)    # 0x7d8bb8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216b59
leaq 0x2f539d(%rip), %rax    # 0x50bef4
jmp 0x216b88
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216b6d
leaq 0x1f9c09(%rip), %rax    # 0x410774
jmp 0x216b88
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216b81
leaq 0x84641(%rip), %rax     # 0x29b1c0
jmp 0x216b88
leaq 0xf6638(%rip), %rax     # 0x30d1c0
movq %rax, 0x5c2031(%rip)    # 0x7d8bc0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216be2
leaq 0x2f6db4(%rip), %rax    # 0x50d994
jmp 0x216c11
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216bf6
leaq 0x1fb474(%rip), %rax    # 0x412068
jmp 0x216c11
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216c0a
leaq 0x845b8(%rip), %rax     # 0x29b1c0
jmp 0x216c11
leaq 0xf8387(%rip), %rax     # 0x30ef98
movq %rax, 0x5c1fb0(%rip)    # 0x7d8bc8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216c6b
leaq 0x2f995f(%rip), %rax    # 0x5105c8
jmp 0x216c9a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216c7f
leaq 0x1fd34b(%rip), %rax    # 0x413fc8
jmp 0x216c9a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216c93
leaq 0x8452f(%rip), %rax     # 0x29b1c0
jmp 0x216c9a
leaq 0xfa656(%rip), %rax     # 0x3112f0
movq %rax, 0x5c1f2f(%rip)    # 0x7d8bd0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216cf4
leaq 0x2fd9d2(%rip), %rax    # 0x5146c4
jmp 0x216d23
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216d08
leaq 0x1ffc36(%rip), %rax    # 0x41693c
jmp 0x216d23
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216d1c
leaq 0x844a6(%rip), %rax     # 0x29b1c0
jmp 0x216d23
leaq 0xfd821(%rip), %rax     # 0x314544
movq %rax, 0x5c1eae(%rip)    # 0x7d8bd8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216d7d
leaq 0x2e79b1(%rip), %rax    # 0x4fe72c
jmp 0x216dac
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216d91
leaq 0x1f00c1(%rip), %rax    # 0x406e50
jmp 0x216dac
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216da5
leaq 0x8441d(%rip), %rax     # 0x29b1c0
jmp 0x216dac
leaq 0xeb5a4(%rip), %rax     # 0x302350
movq %rax, 0x5c1e2d(%rip)    # 0x7d8be0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216e06
leaq 0x2e9cc4(%rip), %rax    # 0x500ac8
jmp 0x216e35
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216e1a
leaq 0x1f1c20(%rip), %rax    # 0x408a38
jmp 0x216e35
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216e2e
leaq 0x84394(%rip), %rax     # 0x29b1c0
jmp 0x216e35
leaq 0xed617(%rip), %rax     # 0x30444c
movq %rax, 0x5c1dac(%rip)    # 0x7d8be8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/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 0x5c8fdb
testl %eax, %eax
je 0x216e8f
leaq 0x2ed0bf(%rip), %rax    # 0x503f4c
jmp 0x216ebe
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x216ea3
leaq 0x1f3eb3(%rip), %rax    # 0x40ad54
jmp 0x216ebe
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x216eb7
leaq 0x8430b(%rip), %rax     # 0x29b1c0
jmp 0x216ebe
leaq 0xefb0a(%rip), %rax     # 0x3069c8
movq %rax, 0x5c1d2b(%rip)    # 0x7d8bf0
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