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_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x2130fb
leaq 0x36738f(%rip), %rax    # 0x57a488
jmp 0x21312a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21310f
leaq 0x2584c3(%rip), %rax    # 0x46b5d0
jmp 0x21312a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213123
leaq 0x8937d(%rip), %rax     # 0x29c49e
jmp 0x21312a
leaq 0x162a7d(%rip), %rax    # 0x375ba7
movq %rax, 0x5c573f(%rip)    # 0x7d8870
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_8_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x213184
leaq 0x36c779(%rip), %rax    # 0x57f8fb
jmp 0x2131b3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213198
leaq 0x25cee9(%rip), %rax    # 0x47007f
jmp 0x2131b3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2131ac
leaq 0x892f4(%rip), %rax     # 0x29c49e
jmp 0x2131b3
leaq 0x168090(%rip), %rax    # 0x37b243
movq %rax, 0x5c56be(%rip)    # 0x7d8878
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_striped_64_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x21320d
leaq 0x38544b(%rip), %rax    # 0x598656
jmp 0x21323c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213221
leaq 0x271e15(%rip), %rax    # 0x485034
jmp 0x21323c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213235
leaq 0x87f6f(%rip), %rax     # 0x29b1a2
jmp 0x21323c
leaq 0x17fcdb(%rip), %rax    # 0x392f17
movq %rax, 0x5c563d(%rip)    # 0x7d8880
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_striped_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x213296
leaq 0x38880a(%rip), %rax    # 0x59ba9e
jmp 0x2132c5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2132aa
leaq 0x275061(%rip), %rax    # 0x488309
jmp 0x2132c5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2132be
leaq 0x87ee6(%rip), %rax     # 0x29b1a2
jmp 0x2132c5
leaq 0x1839ff(%rip), %rax    # 0x396cc4
movq %rax, 0x5c55bc(%rip)    # 0x7d8888
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_striped_16_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x21331f
leaq 0x38cf66(%rip), %rax    # 0x5a0283
jmp 0x21334e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213333
leaq 0x278954(%rip), %rax    # 0x48bc85
jmp 0x21334e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213347
leaq 0x87e5d(%rip), %rax     # 0x29b1a2
jmp 0x21334e
leaq 0x18798b(%rip), %rax    # 0x39acd9
movq %rax, 0x5c553b(%rip)    # 0x7d8890
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_striped_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2133a8
leaq 0x3926e8(%rip), %rax    # 0x5a5a8e
jmp 0x2133d7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2133bc
leaq 0x27d060(%rip), %rax    # 0x49041a
jmp 0x2133d7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2133d0
leaq 0x87dd4(%rip), %rax     # 0x29b1a2
jmp 0x2133d7
leaq 0x18ca24(%rip), %rax    # 0x39fdfb
movq %rax, 0x5c54ba(%rip)    # 0x7d8898
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_diag_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213431
leaq 0x37061f(%rip), %rax    # 0x583a4e
jmp 0x213460
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213445
leaq 0x2609f0(%rip), %rax    # 0x473e33
jmp 0x213460
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213459
leaq 0x87d4b(%rip), %rax     # 0x29b1a2
jmp 0x213460
leaq 0x16c577(%rip), %rax    # 0x37f9d7
movq %rax, 0x5c5439(%rip)    # 0x7d88a0
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_diag_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2134ba
leaq 0x374685(%rip), %rax    # 0x587b3d
jmp 0x2134e9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2134ce
leaq 0x264544(%rip), %rax    # 0x477a10
jmp 0x2134e9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2134e2
leaq 0x87cc2(%rip), %rax     # 0x29b1a2
jmp 0x2134e9
leaq 0x17098c(%rip), %rax    # 0x383e75
movq %rax, 0x5c53b8(%rip)    # 0x7d88a8
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_diag_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213543
leaq 0x37983e(%rip), %rax    # 0x58cd7f
jmp 0x213572
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213557
leaq 0x2687a8(%rip), %rax    # 0x47bcfd
jmp 0x213572
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21356b
leaq 0x87c39(%rip), %rax     # 0x29b1a2
jmp 0x213572
leaq 0x174ef4(%rip), %rax    # 0x388466
movq %rax, 0x5c5337(%rip)    # 0x7d88b0
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_diag_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2135cc
leaq 0x380749(%rip), %rax    # 0x593d13
jmp 0x2135fb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2135e0
leaq 0x26dbc5(%rip), %rax    # 0x4811a3
jmp 0x2135fb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2135f4
leaq 0x87bb0(%rip), %rax     # 0x29b1a2
jmp 0x2135fb
leaq 0x17abde(%rip), %rax    # 0x38e1d9
movq %rax, 0x5c52b6(%rip)    # 0x7d88b8
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_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_trace_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213655
leaq 0x394c7b(%rip), %rax    # 0x5a82ce
jmp 0x213684
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213669
leaq 0x27f8aa(%rip), %rax    # 0x492f11
jmp 0x213684
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21367d
leaq 0x88e23(%rip), %rax     # 0x29c49e
jmp 0x213684
leaq 0x18f9ba(%rip), %rax    # 0x3a303e
movq %rax, 0x5c5235(%rip)    # 0x7d88c0
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_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_trace_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2136de
leaq 0x3968bc(%rip), %rax    # 0x5a9f98
jmp 0x21370d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2136f2
leaq 0x2814b7(%rip), %rax    # 0x494ba7
jmp 0x21370d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213706
leaq 0x88d9a(%rip), %rax     # 0x29c49e
jmp 0x21370d
leaq 0x191b50(%rip), %rax    # 0x3a525d
movq %rax, 0x5c51b4(%rip)    # 0x7d88c8
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_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_trace_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213767
leaq 0x398f26(%rip), %rax    # 0x5ac68b
jmp 0x213796
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21377b
leaq 0x28334e(%rip), %rax    # 0x496ac7
jmp 0x213796
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21378f
leaq 0x88d11(%rip), %rax     # 0x29c49e
jmp 0x213796
leaq 0x193e90(%rip), %rax    # 0x3a7626
movq %rax, 0x5c5133(%rip)    # 0x7d88d0
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_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_trace_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2137f0
leaq 0x39c33e(%rip), %rax    # 0x5afb2c
jmp 0x21381f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213804
leaq 0x2855f1(%rip), %rax    # 0x498df3
jmp 0x21381f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213818
leaq 0x88c88(%rip), %rax     # 0x29c49e
jmp 0x21381f
leaq 0x1969ec(%rip), %rax    # 0x3aa20b
movq %rax, 0x5c50b2(%rip)    # 0x7d88d8
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_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_trace_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_trace_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213879
leaq 0x3ac357(%rip), %rax    # 0x5bfbce
jmp 0x2138a8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21388d
leaq 0x2914b3(%rip), %rax    # 0x4a4d3e
jmp 0x2138a8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2138a1
leaq 0x87903(%rip), %rax     # 0x29b1a2
jmp 0x2138a8
leaq 0x1a4804(%rip), %rax    # 0x3b80ac
movq %rax, 0x5c5031(%rip)    # 0x7d88e0
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_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_trace_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_trace_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213902
leaq 0x3ae43f(%rip), %rax    # 0x5c1d3f
jmp 0x213931
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213916
leaq 0x29364d(%rip), %rax    # 0x4a6f61
jmp 0x213931
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21392a
leaq 0x8787a(%rip), %rax     # 0x29b1a2
jmp 0x213931
leaq 0x1a70e4(%rip), %rax    # 0x3baa15
movq %rax, 0x5c4fb0(%rip)    # 0x7d88e8
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_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_trace_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_trace_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21398b
leaq 0x3b100e(%rip), %rax    # 0x5c4997
jmp 0x2139ba
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21399f
leaq 0x295aa6(%rip), %rax    # 0x4a9443
jmp 0x2139ba
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2139b3
leaq 0x877f1(%rip), %rax     # 0x29b1a2
jmp 0x2139ba
leaq 0x1a9a01(%rip), %rax    # 0x3bd3bb
movq %rax, 0x5c4f2f(%rip)    # 0x7d88f0
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_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_trace_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_trace_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213a14
leaq 0x3b49e7(%rip), %rax    # 0x5c83f9
jmp 0x213a43
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213a28
leaq 0x29830e(%rip), %rax    # 0x4abd34
jmp 0x213a43
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213a3c
leaq 0x87768(%rip), %rax     # 0x29b1a2
jmp 0x213a43
leaq 0x1acb8b(%rip), %rax    # 0x3c05ce
movq %rax, 0x5c4eae(%rip)    # 0x7d88f8
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_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_trace_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_trace_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213a9d
leaq 0x39e18f(%rip), %rax    # 0x5b1c2a
jmp 0x213acc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213ab1
leaq 0x28706f(%rip), %rax    # 0x49ab1e
jmp 0x213acc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213ac5
leaq 0x876df(%rip), %rax     # 0x29b1a2
jmp 0x213acc
leaq 0x198c12(%rip), %rax    # 0x3ac6de
movq %rax, 0x5c4e2d(%rip)    # 0x7d8900
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_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_trace_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_trace_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213b26
leaq 0x3a06f6(%rip), %rax    # 0x5b421a
jmp 0x213b55
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213b3a
leaq 0x288dd5(%rip), %rax    # 0x49c90d
jmp 0x213b55
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213b4e
leaq 0x87656(%rip), %rax     # 0x29b1a2
jmp 0x213b55
leaq 0x19aea6(%rip), %rax    # 0x3ae9fb
movq %rax, 0x5c4dac(%rip)    # 0x7d8908
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_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_trace_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_trace_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213baf
leaq 0x3a3c1d(%rip), %rax    # 0x5b77ca
jmp 0x213bde
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213bc3
leaq 0x28b16d(%rip), %rax    # 0x49ed2e
jmp 0x213bde
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213bd7
leaq 0x875cd(%rip), %rax     # 0x29b1a2
jmp 0x213bde
leaq 0x19d4be(%rip), %rax    # 0x3b109c
movq %rax, 0x5c4d2b(%rip)    # 0x7d8910
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_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_trace_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_trace_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x213c38
leaq 0x3a8c03(%rip), %rax    # 0x5bc839
jmp 0x213c67
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x213c4c
leaq 0x28e56e(%rip), %rax    # 0x4a21b8
jmp 0x213c67
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x213c60
leaq 0x87544(%rip), %rax     # 0x29b1a2
jmp 0x213c67
leaq 0x1a0e63(%rip), %rax    # 0x3b4aca
movq %rax, 0x5c4caa(%rip)    # 0x7d8918
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