LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_stats_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212535
leaq 0x32b8cc(%rip), %rax    # 0x53ddff
jmp 0x212564
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212549
leaq 0x227e1a(%rip), %rax    # 0x43a361
jmp 0x212564
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21255d
leaq 0x88c47(%rip), %rax     # 0x29b1a2
jmp 0x212564
leaq 0x12ab9e(%rip), %rax    # 0x33d102
movq %rax, 0x5c6255(%rip)    # 0x7d87c0
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/sg_dispatch.c
// Function: parasail_sg_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_stats_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2125be
leaq 0x32ee9e(%rip), %rax    # 0x54145a
jmp 0x2125ed
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2125d2
leaq 0x22b1b5(%rip), %rax    # 0x43d785
jmp 0x2125ed
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2125e6
leaq 0x88bbe(%rip), %rax     # 0x29b1a2
jmp 0x2125ed
leaq 0x12e9ac(%rip), %rax    # 0x340f99
movq %rax, 0x5c61d4(%rip)    # 0x7d87c8
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/sg_dispatch.c
// Function: parasail_sg_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_stats_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212647
leaq 0x333ec0(%rip), %rax    # 0x546505
jmp 0x212676
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21265b
leaq 0x22f0e8(%rip), %rax    # 0x441741
jmp 0x212676
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21266f
leaq 0x88b35(%rip), %rax     # 0x29b1a2
jmp 0x212676
leaq 0x132e3a(%rip), %rax    # 0x3454b0
movq %rax, 0x5c6153(%rip)    # 0x7d87d0
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/sg_dispatch.c
// Function: parasail_sg_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_stats_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2126d0
leaq 0x33a05f(%rip), %rax    # 0x54c72d
jmp 0x2126ff
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2126e4
leaq 0x23447e(%rip), %rax    # 0x446b60
jmp 0x2126ff
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2126f8
leaq 0x88aac(%rip), %rax     # 0x29b1a2
jmp 0x2126ff
leaq 0x138d18(%rip), %rax    # 0x34b417
movq %rax, 0x5c60d2(%rip)    # 0x7d87d8
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/sg_dispatch.c
// Function: parasail_sg_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212759
leaq 0x31672b(%rip), %rax    # 0x528e82
jmp 0x212788
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21276d
leaq 0x216fff(%rip), %rax    # 0x42976a
jmp 0x212788
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212781
leaq 0x88a23(%rip), %rax     # 0x29b1a2
jmp 0x212788
leaq 0x117966(%rip), %rax    # 0x32a0ee
movq %rax, 0x5c6051(%rip)    # 0x7d87e0
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/sg_dispatch.c
// Function: parasail_sg_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2127e2
leaq 0x31ad8d(%rip), %rax    # 0x52d56d
jmp 0x212811
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2127f6
leaq 0x21a85b(%rip), %rax    # 0x42d04f
jmp 0x212811
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21280a
leaq 0x8899a(%rip), %rax     # 0x29b1a2
jmp 0x212811
leaq 0x11bb0c(%rip), %rax    # 0x32e31d
movq %rax, 0x5c5fd0(%rip)    # 0x7d87e8
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/sg_dispatch.c
// Function: parasail_sg_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21286b
leaq 0x3200d4(%rip), %rax    # 0x53293d
jmp 0x21289a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21287f
leaq 0x21e900(%rip), %rax    # 0x43117d
jmp 0x21289a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212893
leaq 0x88911(%rip), %rax     # 0x29b1a2
jmp 0x21289a
leaq 0x11fef4(%rip), %rax    # 0x33278e
movq %rax, 0x5c5f4f(%rip)    # 0x7d87f0
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/sg_dispatch.c
// Function: parasail_sg_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2128f4
leaq 0x326ca3(%rip), %rax    # 0x539595
jmp 0x212923
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212908
leaq 0x223b74(%rip), %rax    # 0x43647a
jmp 0x212923
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21291c
leaq 0x88888(%rip), %rax     # 0x29b1a2
jmp 0x212923
leaq 0x125ac2(%rip), %rax    # 0x3383e5
movq %rax, 0x5c5ece(%rip)    # 0x7d87f8
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/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21297d
leaq 0x33c6f5(%rip), %rax    # 0x54f070
jmp 0x2129ac
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212991
leaq 0x237045(%rip), %rax    # 0x4499d4
jmp 0x2129ac
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2129a5
leaq 0x89afb(%rip), %rax     # 0x29c49e
jmp 0x2129ac
leaq 0x13c1c4(%rip), %rax    # 0x34eb70
movq %rax, 0x5c5e4d(%rip)    # 0x7d8800
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/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212a06
leaq 0x33e21a(%rip), %rax    # 0x550c1e
jmp 0x212a35
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212a1a
leaq 0x238b34(%rip), %rax    # 0x44b54c
jmp 0x212a35
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212a2e
leaq 0x89a72(%rip), %rax     # 0x29c49e
jmp 0x212a35
leaq 0x13e1a4(%rip), %rax    # 0x350bd9
movq %rax, 0x5c5dcc(%rip)    # 0x7d8808
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/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212a8f
leaq 0x340b52(%rip), %rax    # 0x5535df
jmp 0x212abe
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212aa3
leaq 0x23a932(%rip), %rax    # 0x44d3d3
jmp 0x212abe
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212ab7
leaq 0x899e9(%rip), %rax     # 0x29c49e
jmp 0x212abe
leaq 0x140491(%rip), %rax    # 0x352f4f
movq %rax, 0x5c5d4b(%rip)    # 0x7d8810
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/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212b18
leaq 0x3447ed(%rip), %rax    # 0x557303
jmp 0x212b47
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212b2c
leaq 0x23ce84(%rip), %rax    # 0x44f9ae
jmp 0x212b47
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212b40
leaq 0x89960(%rip), %rax     # 0x29c49e
jmp 0x212b47
leaq 0x1432e3(%rip), %rax    # 0x355e2a
movq %rax, 0x5c5cca(%rip)    # 0x7d8818
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/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212ba1
leaq 0x354aeb(%rip), %rax    # 0x56768a
jmp 0x212bd0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212bb5
leaq 0x24887a(%rip), %rax    # 0x45b42d
jmp 0x212bd0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212bc9
leaq 0x885db(%rip), %rax     # 0x29b1a2
jmp 0x212bd0
leaq 0x1508d4(%rip), %rax    # 0x3634a4
movq %rax, 0x5c5c49(%rip)    # 0x7d8820
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/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212c2a
leaq 0x35632a(%rip), %rax    # 0x568f52
jmp 0x212c59
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212c3e
leaq 0x24a06f(%rip), %rax    # 0x45ccab
jmp 0x212c59
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212c52
leaq 0x88552(%rip), %rax     # 0x29b1a2
jmp 0x212c59
leaq 0x1525a5(%rip), %rax    # 0x3651fe
movq %rax, 0x5c5bc8(%rip)    # 0x7d8828
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/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_rowcol_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_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_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 0x212cb3
leaq 0x358950(%rip), %rax    # 0x56b601
jmp 0x212ce2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212cc7
leaq 0x24bbf3(%rip), %rax    # 0x45e8b8
jmp 0x212ce2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212cdb
leaq 0x884c9(%rip), %rax     # 0x29b1a2
jmp 0x212ce2
leaq 0x154554(%rip), %rax    # 0x367236
movq %rax, 0x5c5b47(%rip)    # 0x7d8830
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/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_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_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x5c8fdb
testl %eax, %eax
je 0x212d3c
leaq 0x35c389(%rip), %rax    # 0x56f0c3
jmp 0x212d6b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212d50
leaq 0x24dece(%rip), %rax    # 0x460c1c
jmp 0x212d6b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212d64
leaq 0x88440(%rip), %rax     # 0x29b1a2
jmp 0x212d6b
leaq 0x157033(%rip), %rax    # 0x369d9e
movq %rax, 0x5c5ac6(%rip)    # 0x7d8838
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/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_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_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x5c8fdb
testl %eax, %eax
je 0x212dc5
leaq 0x34683f(%rip), %rax    # 0x559602
jmp 0x212df4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212dd9
leaq 0x23e990(%rip), %rax    # 0x451767
jmp 0x212df4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212ded
leaq 0x883b7(%rip), %rax     # 0x29b1a2
jmp 0x212df4
leaq 0x14546a(%rip), %rax    # 0x35825e
movq %rax, 0x5c5a45(%rip)    # 0x7d8840
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/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_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_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x5c8fdb
testl %eax, %eax
je 0x212e4e
leaq 0x348c78(%rip), %rax    # 0x55bac4
jmp 0x212e7d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212e62
leaq 0x24054a(%rip), %rax    # 0x4533aa
jmp 0x212e7d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212e76
leaq 0x8832e(%rip), %rax     # 0x29b1a2
jmp 0x212e7d
leaq 0x147538(%rip), %rax    # 0x35a3b5
movq %rax, 0x5c59c4(%rip)    # 0x7d8848
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/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_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_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x5c8fdb
testl %eax, %eax
je 0x212ed7
leaq 0x34c318(%rip), %rax    # 0x55f1ed
jmp 0x212f06
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212eeb
leaq 0x242907(%rip), %rax    # 0x4557f0
jmp 0x212f06
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212eff
leaq 0x882a5(%rip), %rax     # 0x29b1a2
jmp 0x212f06
leaq 0x149b94(%rip), %rax    # 0x35ca9a
movq %rax, 0x5c5943(%rip)    # 0x7d8850
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/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_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_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x5c8fdb
testl %eax, %eax
je 0x212f60
leaq 0x3518c9(%rip), %rax    # 0x564827
jmp 0x212f8f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212f74
leaq 0x245f36(%rip), %rax    # 0x458ea8
jmp 0x212f8f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212f88
leaq 0x8821c(%rip), %rax     # 0x29b1a2
jmp 0x212f8f
leaq 0x14d79a(%rip), %rax    # 0x360729
movq %rax, 0x5c58c2(%rip)    # 0x7d8858
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/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212fe9
leaq 0x35f216(%rip), %rax    # 0x5721fd
jmp 0x213018
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212ffd
leaq 0x25126a(%rip), %rax    # 0x464265
jmp 0x213018
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213011
leaq 0x8948f(%rip), %rax     # 0x29c49e
jmp 0x213018
leaq 0x15a70a(%rip), %rax    # 0x36d722
movq %rax, 0x5c5841(%rip)    # 0x7d8860
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/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213072
leaq 0x362a1d(%rip), %rax    # 0x575a8d
jmp 0x2130a1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213086
leaq 0x2547a0(%rip), %rax    # 0x467824
jmp 0x2130a1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21309a
leaq 0x89406(%rip), %rax     # 0x29c49e
jmp 0x2130a1
leaq 0x15e57b(%rip), %rax    # 0x37161c
movq %rax, 0x5c57c0(%rip)    # 0x7d8868
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