LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220b6e
leaq 0x3207d1(%rip), %rax    # 0x54133d
jmp 0x220b9d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220b82
leaq 0x21cae8(%rip), %rax    # 0x43d668
jmp 0x220b9d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220b96
leaq 0x7a4f1(%rip), %rax     # 0x29b085
jmp 0x220b9d
leaq 0x1202df(%rip), %rax    # 0x340e7c
movq %rax, 0x5b8944(%rip)    # 0x7d94e8
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220bf7
leaq 0x3257f3(%rip), %rax    # 0x5463e8
jmp 0x220c26
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220c0b
leaq 0x220a1b(%rip), %rax    # 0x441624
jmp 0x220c26
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220c1f
leaq 0x7a468(%rip), %rax     # 0x29b085
jmp 0x220c26
leaq 0x12476d(%rip), %rax    # 0x345393
movq %rax, 0x5b88c3(%rip)    # 0x7d94f0
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220c80
leaq 0x32b992(%rip), %rax    # 0x54c610
jmp 0x220caf
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220c94
leaq 0x225db1(%rip), %rax    # 0x446a43
jmp 0x220caf
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220ca8
leaq 0x7a3df(%rip), %rax     # 0x29b085
jmp 0x220caf
leaq 0x12a64b(%rip), %rax    # 0x34b2fa
movq %rax, 0x5b8842(%rip)    # 0x7d94f8
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220d09
leaq 0x30805e(%rip), %rax    # 0x528d65
jmp 0x220d38
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220d1d
leaq 0x208932(%rip), %rax    # 0x42964d
jmp 0x220d38
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220d31
leaq 0x7a356(%rip), %rax     # 0x29b085
jmp 0x220d38
leaq 0x109299(%rip), %rax    # 0x329fd1
movq %rax, 0x5b87c1(%rip)    # 0x7d9500
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220d92
leaq 0x30c6c0(%rip), %rax    # 0x52d450
jmp 0x220dc1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220da6
leaq 0x20c18e(%rip), %rax    # 0x42cf32
jmp 0x220dc1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220dba
leaq 0x7a2cd(%rip), %rax     # 0x29b085
jmp 0x220dc1
leaq 0x10d43f(%rip), %rax    # 0x32e200
movq %rax, 0x5b8740(%rip)    # 0x7d9508
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220e1b
leaq 0x311a07(%rip), %rax    # 0x532820
jmp 0x220e4a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220e2f
leaq 0x210233(%rip), %rax    # 0x431060
jmp 0x220e4a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220e43
leaq 0x7a244(%rip), %rax     # 0x29b085
jmp 0x220e4a
leaq 0x111827(%rip), %rax    # 0x332671
movq %rax, 0x5b86bf(%rip)    # 0x7d9510
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x220ea4
leaq 0x3185d6(%rip), %rax    # 0x539478
jmp 0x220ed3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220eb8
leaq 0x2154a7(%rip), %rax    # 0x43635d
jmp 0x220ed3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220ecc
leaq 0x7a1bb(%rip), %rax     # 0x29b085
jmp 0x220ed3
leaq 0x1173f5(%rip), %rax    # 0x3382c8
movq %rax, 0x5b863e(%rip)    # 0x7d9518
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x220f2d
leaq 0x32e028(%rip), %rax    # 0x54ef53
jmp 0x220f5c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220f41
leaq 0x228978(%rip), %rax    # 0x4498b7
jmp 0x220f5c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220f55
leaq 0x7b42e(%rip), %rax     # 0x29c381
jmp 0x220f5c
leaq 0x12daf7(%rip), %rax    # 0x34ea53
movq %rax, 0x5b85bd(%rip)    # 0x7d9520
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x220fb6
leaq 0x32fb4d(%rip), %rax    # 0x550b01
jmp 0x220fe5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220fca
leaq 0x22a467(%rip), %rax    # 0x44b42f
jmp 0x220fe5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220fde
leaq 0x7b3a5(%rip), %rax     # 0x29c381
jmp 0x220fe5
leaq 0x12fad7(%rip), %rax    # 0x350abc
movq %rax, 0x5b853c(%rip)    # 0x7d9528
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x22103f
leaq 0x332485(%rip), %rax    # 0x5534c2
jmp 0x22106e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221053
leaq 0x22c265(%rip), %rax    # 0x44d2b6
jmp 0x22106e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x221067
leaq 0x7b31c(%rip), %rax     # 0x29c381
jmp 0x22106e
leaq 0x131dc4(%rip), %rax    # 0x352e32
movq %rax, 0x5b84bb(%rip)    # 0x7d9530
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x2210c8
leaq 0x336120(%rip), %rax    # 0x5571e6
jmp 0x2210f7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2210dc
leaq 0x22e7b7(%rip), %rax    # 0x44f891
jmp 0x2210f7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2210f0
leaq 0x7b293(%rip), %rax     # 0x29c381
jmp 0x2210f7
leaq 0x134c16(%rip), %rax    # 0x355d0d
movq %rax, 0x5b843a(%rip)    # 0x7d9538
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x221151
leaq 0x34641e(%rip), %rax    # 0x56756d
jmp 0x221180
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221165
leaq 0x23a1ad(%rip), %rax    # 0x45b310
jmp 0x221180
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x221179
leaq 0x79f0e(%rip), %rax     # 0x29b085
jmp 0x221180
leaq 0x142207(%rip), %rax    # 0x363387
movq %rax, 0x5b83b9(%rip)    # 0x7d9540
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x2211da
leaq 0x347c5d(%rip), %rax    # 0x568e35
jmp 0x221209
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2211ee
leaq 0x23b9a2(%rip), %rax    # 0x45cb8e
jmp 0x221209
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x221202
leaq 0x79e85(%rip), %rax     # 0x29b085
jmp 0x221209
leaq 0x143ed8(%rip), %rax    # 0x3650e1
movq %rax, 0x5b8338(%rip)    # 0x7d9548
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x221263
leaq 0x34a283(%rip), %rax    # 0x56b4e4
jmp 0x221292
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221277
leaq 0x23d526(%rip), %rax    # 0x45e79b
jmp 0x221292
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22128b
leaq 0x79dfc(%rip), %rax     # 0x29b085
jmp 0x221292
leaq 0x145e87(%rip), %rax    # 0x367119
movq %rax, 0x5b82b7(%rip)    # 0x7d9550
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x2212ec
leaq 0x34dcbc(%rip), %rax    # 0x56efa6
jmp 0x22131b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221300
leaq 0x23f801(%rip), %rax    # 0x460aff
jmp 0x22131b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x221314
leaq 0x79d73(%rip), %rax     # 0x29b085
jmp 0x22131b
leaq 0x148966(%rip), %rax    # 0x369c81
movq %rax, 0x5b8236(%rip)    # 0x7d9558
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x221375
leaq 0x338172(%rip), %rax    # 0x5594e5
jmp 0x2213a4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221389
leaq 0x2302c3(%rip), %rax    # 0x45164a
jmp 0x2213a4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22139d
leaq 0x79cea(%rip), %rax     # 0x29b085
jmp 0x2213a4
leaq 0x136d9d(%rip), %rax    # 0x358141
movq %rax, 0x5b81b5(%rip)    # 0x7d9560
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x2213fe
leaq 0x33a5ab(%rip), %rax    # 0x55b9a7
jmp 0x22142d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221412
leaq 0x231e7d(%rip), %rax    # 0x45328d
jmp 0x22142d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x221426
leaq 0x79c61(%rip), %rax     # 0x29b085
jmp 0x22142d
leaq 0x138e6b(%rip), %rax    # 0x35a298
movq %rax, 0x5b8134(%rip)    # 0x7d9568
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x221487
leaq 0x33dc4b(%rip), %rax    # 0x55f0d0
jmp 0x2214b6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22149b
leaq 0x23423a(%rip), %rax    # 0x4556d3
jmp 0x2214b6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2214af
leaq 0x79bd8(%rip), %rax     # 0x29b085
jmp 0x2214b6
leaq 0x13b4c7(%rip), %rax    # 0x35c97d
movq %rax, 0x5b80b3(%rip)    # 0x7d9570
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_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x221510
leaq 0x3431fc(%rip), %rax    # 0x56470a
jmp 0x22153f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221524
leaq 0x237869(%rip), %rax    # 0x458d8b
jmp 0x22153f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x221538
leaq 0x79b4f(%rip), %rax     # 0x29b085
jmp 0x22153f
leaq 0x13f0cd(%rip), %rax    # 0x36060c
movq %rax, 0x5b8032(%rip)    # 0x7d9578
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x221599
leaq 0x350b49(%rip), %rax    # 0x5720e0
jmp 0x2215c8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2215ad
leaq 0x242b9d(%rip), %rax    # 0x464148
jmp 0x2215c8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2215c1
leaq 0x7adc2(%rip), %rax     # 0x29c381
jmp 0x2215c8
leaq 0x14c03d(%rip), %rax    # 0x36d605
movq %rax, 0x5b7fb1(%rip)    # 0x7d9580
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x221622
leaq 0x354350(%rip), %rax    # 0x575970
jmp 0x221651
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x221636
leaq 0x2460d3(%rip), %rax    # 0x467707
jmp 0x221651
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22164a
leaq 0x7ad39(%rip), %rax     # 0x29c381
jmp 0x221651
leaq 0x14feae(%rip), %rax    # 0x3714ff
movq %rax, 0x5b7f30(%rip)    # 0x7d9588
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x2216ab
leaq 0x358cc2(%rip), %rax    # 0x57a36b
jmp 0x2216da
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2216bf
leaq 0x249df6(%rip), %rax    # 0x46b4b3
jmp 0x2216da
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2216d3
leaq 0x7acb0(%rip), %rax     # 0x29c381
jmp 0x2216da
leaq 0x1543b0(%rip), %rax    # 0x375a8a
movq %rax, 0x5b7eaf(%rip)    # 0x7d9590
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