LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2243a1
leaq 0x2d5d6d(%rip), %rax    # 0x4fa10c
jmp 0x2243d0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2243b5
leaq 0x1e0c60(%rip), %rax    # 0x405013
jmp 0x2243d0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2243c9
leaq 0x7570b(%rip), %rax     # 0x299ad2
jmp 0x2243d0
leaq 0xf39b9(%rip), %rax     # 0x317d89
movq %rax, 0x57f589(%rip)    # 0x7a3960
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22442a
leaq 0x2da7cc(%rip), %rax    # 0x4febf4
jmp 0x224459
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22443e
leaq 0x1e4721(%rip), %rax    # 0x408b5d
jmp 0x224459
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224452
leaq 0x75682(%rip), %rax     # 0x299ad2
jmp 0x224459
leaq 0xf7aad(%rip), %rax     # 0x31bf06
movq %rax, 0x57f508(%rip)    # 0x7a3968
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2244b3
leaq 0x2dfb4a(%rip), %rax    # 0x503ffb
jmp 0x2244e2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2244c7
leaq 0x1e88cf(%rip), %rax    # 0x40cd94
jmp 0x2244e2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2244db
leaq 0x755f9(%rip), %rax     # 0x299ad2
jmp 0x2244e2
leaq 0xfbf5e(%rip), %rax     # 0x320440
movq %rax, 0x57f487(%rip)    # 0x7a3970
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22453c
leaq 0x2e6ce0(%rip), %rax    # 0x50b21a
jmp 0x22456b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224550
leaq 0x1eda53(%rip), %rax    # 0x411fa1
jmp 0x22456b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224564
leaq 0x75570(%rip), %rax     # 0x299ad2
jmp 0x22456b
leaq 0x1017a4(%rip), %rax    # 0x325d0f
movq %rax, 0x57f406(%rip)    # 0x7a3978
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2245c5
leaq 0x2fbf4b(%rip), %rax    # 0x52050e
jmp 0x2245f4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2245d9
leaq 0x2006f0(%rip), %rax    # 0x424cc7
jmp 0x2245f4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2245ed
leaq 0x76365(%rip), %rax     # 0x29a950
jmp 0x2245f4
leaq 0x115c3b(%rip), %rax    # 0x33a22f
movq %rax, 0x57f385(%rip)    # 0x7a3980
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22464e
leaq 0x2fdd5b(%rip), %rax    # 0x5223a7
jmp 0x22467d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224662
leaq 0x202096(%rip), %rax    # 0x4266f6
jmp 0x22467d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224676
leaq 0x762dc(%rip), %rax     # 0x29a950
jmp 0x22467d
leaq 0x117857(%rip), %rax    # 0x33bed4
movq %rax, 0x57f304(%rip)    # 0x7a3988
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2246d7
leaq 0x2ff9a8(%rip), %rax    # 0x52407d
jmp 0x224706
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2246eb
leaq 0x2039d6(%rip), %rax    # 0x4280bf
jmp 0x224706
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2246ff
leaq 0x76253(%rip), %rax     # 0x29a950
jmp 0x224706
leaq 0x1192b7(%rip), %rax    # 0x33d9bd
movq %rax, 0x57f283(%rip)    # 0x7a3990
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224760
leaq 0x301bdf(%rip), %rax    # 0x52633d
jmp 0x22478f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224774
leaq 0x2055f3(%rip), %rax    # 0x429d65
jmp 0x22478f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224788
leaq 0x761ca(%rip), %rax     # 0x29a950
jmp 0x22478f
leaq 0x11b125(%rip), %rax    # 0x33f8b4
movq %rax, 0x57f202(%rip)    # 0x7a3998
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2247e9
leaq 0x314097(%rip), %rax    # 0x53887e
jmp 0x224818
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2247fd
leaq 0x211a26(%rip), %rax    # 0x436221
jmp 0x224818
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224811
leaq 0x752c3(%rip), %rax     # 0x299ad2
jmp 0x224818
leaq 0x1283b6(%rip), %rax    # 0x34cbce
movq %rax, 0x57f181(%rip)    # 0x7a39a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224872
leaq 0x315b13(%rip), %rax    # 0x53a383
jmp 0x2248a1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224886
leaq 0x213251(%rip), %rax    # 0x437ad5
jmp 0x2248a1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22489a
leaq 0x7523a(%rip), %rax     # 0x299ad2
jmp 0x2248a1
leaq 0x129d46(%rip), %rax    # 0x34e5e7
movq %rax, 0x57f100(%rip)    # 0x7a39a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2248fb
leaq 0x317527(%rip), %rax    # 0x53be20
jmp 0x22492a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22490f
leaq 0x2149ad(%rip), %rax    # 0x4392ba
jmp 0x22492a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224923
leaq 0x751b1(%rip), %rax     # 0x299ad2
jmp 0x22492a
leaq 0x12b568(%rip), %rax    # 0x34fe92
movq %rax, 0x57f07f(%rip)    # 0x7a39b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x224984
leaq 0x31957e(%rip), %rax    # 0x53df00
jmp 0x2249b3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224998
leaq 0x216403(%rip), %rax    # 0x43ad99
jmp 0x2249b3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2249ac
leaq 0x75128(%rip), %rax     # 0x299ad2
jmp 0x2249b3
leaq 0x12d1f7(%rip), %rax    # 0x351baa
movq %rax, 0x57effe(%rip)    # 0x7a39b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x224a0d
leaq 0x304218(%rip), %rax    # 0x528c23
jmp 0x224a3c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224a21
leaq 0x2072fa(%rip), %rax    # 0x42bd19
jmp 0x224a3c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224a35
leaq 0x7509f(%rip), %rax     # 0x299ad2
jmp 0x224a3c
leaq 0x11d150(%rip), %rax    # 0x341b8c
movq %rax, 0x57ef7d(%rip)    # 0x7a39c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x224a96
leaq 0x306a12(%rip), %rax    # 0x52b4a6
jmp 0x224ac5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224aaa
leaq 0x209042(%rip), %rax    # 0x42daea
jmp 0x224ac5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224abe
leaq 0x75016(%rip), %rax     # 0x299ad2
jmp 0x224ac5
leaq 0x11f24a(%rip), %rax    # 0x343d0f
movq %rax, 0x57eefc(%rip)    # 0x7a39c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_diag_16_pointer = parasail_sg_qx_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_diag_16_pointer = parasail_sg_qx_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_diag_16_pointer = parasail_sg_qx_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_diag_16_pointer = parasail_sg_qx_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_diag_16_pointer = parasail_sg_qx_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x224b1f
leaq 0x30a1ee(%rip), %rax    # 0x52ed0b
jmp 0x224b4e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224b33
leaq 0x20b519(%rip), %rax    # 0x43004a
jmp 0x224b4e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224b47
leaq 0x74f8d(%rip), %rax     # 0x299ad2
jmp 0x224b4e
leaq 0x12194a(%rip), %rax    # 0x346498
movq %rax, 0x57ee7b(%rip)    # 0x7a39d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_rowcol_diag_8_pointer = parasail_sg_qx_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_diag_8_pointer = parasail_sg_qx_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_diag_8_pointer = parasail_sg_qx_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_diag_8_pointer = parasail_sg_qx_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_diag_8_pointer = parasail_sg_qx_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x224ba8
leaq 0x30ffa5(%rip), %rax    # 0x534b4b
jmp 0x224bd7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224bbc
leaq 0x20ed74(%rip), %rax    # 0x43392e
jmp 0x224bd7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224bd0
leaq 0x74f04(%rip), %rax     # 0x299ad2
jmp 0x224bd7
leaq 0x125474(%rip), %rax    # 0x34a04b
movq %rax, 0x57edfa(%rip)    # 0x7a39d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_rowcol_scan_64_pointer = parasail_sg_qx_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_scan_64_pointer = parasail_sg_qx_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_scan_64_pointer = parasail_sg_qx_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_scan_64_pointer = parasail_sg_qx_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_scan_64_pointer = parasail_sg_qx_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224c31
leaq 0x31cf1a(%rip), %rax    # 0x541b49
jmp 0x224c60
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224c45
leaq 0x219a57(%rip), %rax    # 0x43e69a
jmp 0x224c60
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224c59
leaq 0x75cf9(%rip), %rax     # 0x29a950
jmp 0x224c60
leaq 0x130568(%rip), %rax    # 0x3551c8
movq %rax, 0x57ed79(%rip)    # 0x7a39e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_rowcol_scan_32_pointer = parasail_sg_qx_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_scan_32_pointer = parasail_sg_qx_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_scan_32_pointer = parasail_sg_qx_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_scan_32_pointer = parasail_sg_qx_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_scan_32_pointer = parasail_sg_qx_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224cba
leaq 0x320b28(%rip), %rax    # 0x5457e0
jmp 0x224ce9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224cce
leaq 0x21d040(%rip), %rax    # 0x441d0c
jmp 0x224ce9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224ce2
leaq 0x75c70(%rip), %rax     # 0x29a950
jmp 0x224ce9
leaq 0x1341f4(%rip), %rax    # 0x358edd
movq %rax, 0x57ecf8(%rip)    # 0x7a39e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_rowcol_scan_16_pointer = parasail_sg_qx_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_scan_16_pointer = parasail_sg_qx_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_scan_16_pointer = parasail_sg_qx_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_scan_16_pointer = parasail_sg_qx_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_scan_16_pointer = parasail_sg_qx_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224d43
leaq 0x324b49(%rip), %rax    # 0x54988a
jmp 0x224d72
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224d57
leaq 0x2207c2(%rip), %rax    # 0x445517
jmp 0x224d72
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224d6b
leaq 0x75be7(%rip), %rax     # 0x29a950
jmp 0x224d72
leaq 0x137df0(%rip), %rax    # 0x35cb62
movq %rax, 0x57ec77(%rip)    # 0x7a39f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_rowcol_scan_8_pointer = parasail_sg_qx_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_scan_8_pointer = parasail_sg_qx_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_scan_8_pointer = parasail_sg_qx_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_scan_8_pointer = parasail_sg_qx_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_scan_8_pointer = parasail_sg_qx_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224dcc
leaq 0x328bbb(%rip), %rax    # 0x54d985
jmp 0x224dfb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224de0
leaq 0x224810(%rip), %rax    # 0x4495ee
jmp 0x224dfb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224df4
leaq 0x75b5e(%rip), %rax     # 0x29a950
jmp 0x224dfb
leaq 0x13c3f1(%rip), %rax    # 0x3611ec
movq %rax, 0x57ebf6(%rip)    # 0x7a39f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_rowcol_striped_64_pointer = parasail_sg_qx_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_striped_64_pointer = parasail_sg_qx_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_striped_64_pointer = parasail_sg_qx_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_striped_64_pointer = parasail_sg_qx_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_striped_64_pointer = parasail_sg_qx_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224e55
leaq 0x343481(%rip), %rax    # 0x5682d4
jmp 0x224e84
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224e69
leaq 0x239f7e(%rip), %rax    # 0x45ede5
jmp 0x224e84
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224e7d
leaq 0x74c57(%rip), %rax     # 0x299ad2
jmp 0x224e84
leaq 0x1536c2(%rip), %rax    # 0x378546
movq %rax, 0x57eb75(%rip)    # 0x7a3a00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_rowcol_striped_32_pointer = parasail_sg_qx_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_striped_32_pointer = parasail_sg_qx_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_striped_32_pointer = parasail_sg_qx_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_striped_32_pointer = parasail_sg_qx_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_striped_32_pointer = parasail_sg_qx_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224ede
leaq 0x346bf3(%rip), %rax    # 0x56bacf
jmp 0x224f0d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224ef2
leaq 0x23d1e9(%rip), %rax    # 0x4620d9
jmp 0x224f0d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224f06
leaq 0x74bce(%rip), %rax     # 0x299ad2
jmp 0x224f0d
leaq 0x157000(%rip), %rax    # 0x37bf0d
movq %rax, 0x57eaf4(%rip)    # 0x7a3a08
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