LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5c8fdb
testl %eax, %eax
je 0x225ef3
leaq 0x34560e(%rip), %rax    # 0x56b4ff
jmp 0x225f22
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225f07
leaq 0x2388b1(%rip), %rax    # 0x45e7b6
jmp 0x225f22
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225f1b
leaq 0x75187(%rip), %rax     # 0x29b0a0
jmp 0x225f22
leaq 0x141212(%rip), %rax    # 0x367134
movq %rax, 0x5b3a87(%rip)    # 0x7d99b0
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_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 0x5c8fdb
testl %eax, %eax
je 0x225f7c
leaq 0x349047(%rip), %rax    # 0x56efc1
jmp 0x225fab
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x225f90
leaq 0x23ab8c(%rip), %rax    # 0x460b1a
jmp 0x225fab
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x225fa4
leaq 0x750fe(%rip), %rax     # 0x29b0a0
jmp 0x225fab
leaq 0x143cf1(%rip), %rax    # 0x369c9c
movq %rax, 0x5b3a06(%rip)    # 0x7d99b8
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_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 0x5c8fdb
testl %eax, %eax
je 0x226005
leaq 0x3334fd(%rip), %rax    # 0x559500
jmp 0x226034
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226019
leaq 0x22b64e(%rip), %rax    # 0x451665
jmp 0x226034
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22602d
leaq 0x75075(%rip), %rax     # 0x29b0a0
jmp 0x226034
leaq 0x132128(%rip), %rax    # 0x35815c
movq %rax, 0x5b3985(%rip)    # 0x7d99c0
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_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 0x5c8fdb
testl %eax, %eax
je 0x22608e
leaq 0x335936(%rip), %rax    # 0x55b9c2
jmp 0x2260bd
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2260a2
leaq 0x22d208(%rip), %rax    # 0x4532a8
jmp 0x2260bd
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2260b6
leaq 0x74fec(%rip), %rax     # 0x29b0a0
jmp 0x2260bd
leaq 0x1341f6(%rip), %rax    # 0x35a2b3
movq %rax, 0x5b3904(%rip)    # 0x7d99c8
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_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 0x5c8fdb
testl %eax, %eax
je 0x226117
leaq 0x338fd6(%rip), %rax    # 0x55f0eb
jmp 0x226146
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22612b
leaq 0x22f5c5(%rip), %rax    # 0x4556ee
jmp 0x226146
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22613f
leaq 0x74f63(%rip), %rax     # 0x29b0a0
jmp 0x226146
leaq 0x136852(%rip), %rax    # 0x35c998
movq %rax, 0x5b3883(%rip)    # 0x7d99d0
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_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 0x5c8fdb
testl %eax, %eax
je 0x2261a0
leaq 0x33e587(%rip), %rax    # 0x564725
jmp 0x2261cf
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2261b4
leaq 0x232bf4(%rip), %rax    # 0x458da6
jmp 0x2261cf
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2261c8
leaq 0x74eda(%rip), %rax     # 0x29b0a0
jmp 0x2261cf
leaq 0x13a458(%rip), %rax    # 0x360627
movq %rax, 0x5b3802(%rip)    # 0x7d99d8
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_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 0x5c8fdb
testl %eax, %eax
je 0x226229
leaq 0x34bed4(%rip), %rax    # 0x5720fb
jmp 0x226258
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22623d
leaq 0x23df28(%rip), %rax    # 0x464163
jmp 0x226258
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226251
leaq 0x7614d(%rip), %rax     # 0x29c39c
jmp 0x226258
leaq 0x1473c8(%rip), %rax    # 0x36d620
movq %rax, 0x5b3781(%rip)    # 0x7d99e0
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_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 0x5c8fdb
testl %eax, %eax
je 0x2262b2
leaq 0x34f6db(%rip), %rax    # 0x57598b
jmp 0x2262e1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2262c6
leaq 0x24145e(%rip), %rax    # 0x467722
jmp 0x2262e1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2262da
leaq 0x760c4(%rip), %rax     # 0x29c39c
jmp 0x2262e1
leaq 0x14b239(%rip), %rax    # 0x37151a
movq %rax, 0x5b3700(%rip)    # 0x7d99e8
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_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 0x5c8fdb
testl %eax, %eax
je 0x22633b
leaq 0x35404d(%rip), %rax    # 0x57a386
jmp 0x22636a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22634f
leaq 0x245181(%rip), %rax    # 0x46b4ce
jmp 0x22636a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226363
leaq 0x7603b(%rip), %rax     # 0x29c39c
jmp 0x22636a
leaq 0x14f73b(%rip), %rax    # 0x375aa5
movq %rax, 0x5b367f(%rip)    # 0x7d99f0
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_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 0x5c8fdb
testl %eax, %eax
je 0x2263c4
leaq 0x359437(%rip), %rax    # 0x57f7f9
jmp 0x2263f3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2263d8
leaq 0x249ba7(%rip), %rax    # 0x46ff7d
jmp 0x2263f3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2263ec
leaq 0x75fb2(%rip), %rax     # 0x29c39c
jmp 0x2263f3
leaq 0x154d4e(%rip), %rax    # 0x37b141
movq %rax, 0x5b35fe(%rip)    # 0x7d99f8
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_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 0x5c8fdb
testl %eax, %eax
je 0x22644d
leaq 0x372109(%rip), %rax    # 0x598554
jmp 0x22647c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226461
leaq 0x25ead3(%rip), %rax    # 0x484f32
jmp 0x22647c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226475
leaq 0x74c2d(%rip), %rax     # 0x29b0a0
jmp 0x22647c
leaq 0x16c999(%rip), %rax    # 0x392e15
movq %rax, 0x5b357d(%rip)    # 0x7d9a00
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_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 0x5c8fdb
testl %eax, %eax
je 0x2264d6
leaq 0x3754c8(%rip), %rax    # 0x59b99c
jmp 0x226505
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2264ea
leaq 0x261d1f(%rip), %rax    # 0x488207
jmp 0x226505
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2264fe
leaq 0x74ba4(%rip), %rax     # 0x29b0a0
jmp 0x226505
leaq 0x1706bd(%rip), %rax    # 0x396bc2
movq %rax, 0x5b34fc(%rip)    # 0x7d9a08
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22655f
leaq 0x379c24(%rip), %rax    # 0x5a0181
jmp 0x22658e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226573
leaq 0x265612(%rip), %rax    # 0x48bb83
jmp 0x22658e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226587
leaq 0x74b1b(%rip), %rax     # 0x29b0a0
jmp 0x22658e
leaq 0x174649(%rip), %rax    # 0x39abd7
movq %rax, 0x5b347b(%rip)    # 0x7d9a10
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2265e8
leaq 0x37f3a6(%rip), %rax    # 0x5a598c
jmp 0x226617
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2265fc
leaq 0x269d1e(%rip), %rax    # 0x490318
jmp 0x226617
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226610
leaq 0x74a92(%rip), %rax     # 0x29b0a0
jmp 0x226617
leaq 0x1796e2(%rip), %rax    # 0x39fcf9
movq %rax, 0x5b33fa(%rip)    # 0x7d9a18
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x226671
leaq 0x35d2dd(%rip), %rax    # 0x58394c
jmp 0x2266a0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226685
leaq 0x24d6ae(%rip), %rax    # 0x473d31
jmp 0x2266a0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226699
leaq 0x74a09(%rip), %rax     # 0x29b0a0
jmp 0x2266a0
leaq 0x159235(%rip), %rax    # 0x37f8d5
movq %rax, 0x5b3379(%rip)    # 0x7d9a20
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2266fa
leaq 0x361343(%rip), %rax    # 0x587a3b
jmp 0x226729
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22670e
leaq 0x251202(%rip), %rax    # 0x47790e
jmp 0x226729
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226722
leaq 0x74980(%rip), %rax     # 0x29b0a0
jmp 0x226729
leaq 0x15d64a(%rip), %rax    # 0x383d73
movq %rax, 0x5b32f8(%rip)    # 0x7d9a28
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x226783
leaq 0x3664fc(%rip), %rax    # 0x58cc7d
jmp 0x2267b2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226797
leaq 0x255466(%rip), %rax    # 0x47bbfb
jmp 0x2267b2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2267ab
leaq 0x748f7(%rip), %rax     # 0x29b0a0
jmp 0x2267b2
leaq 0x161bb2(%rip), %rax    # 0x388364
movq %rax, 0x5b3277(%rip)    # 0x7d9a30
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22680c
leaq 0x36d407(%rip), %rax    # 0x593c11
jmp 0x22683b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226820
leaq 0x25a883(%rip), %rax    # 0x4810a1
jmp 0x22683b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226834
leaq 0x7486e(%rip), %rax     # 0x29b0a0
jmp 0x22683b
leaq 0x16789c(%rip), %rax    # 0x38e0d7
movq %rax, 0x5b31f6(%rip)    # 0x7d9a38
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x226895
leaq 0x381939(%rip), %rax    # 0x5a81cc
jmp 0x2268c4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2268a9
leaq 0x26c568(%rip), %rax    # 0x492e0f
jmp 0x2268c4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2268bd
leaq 0x75ae1(%rip), %rax     # 0x29c39c
jmp 0x2268c4
leaq 0x17c678(%rip), %rax    # 0x3a2f3c
movq %rax, 0x5b3175(%rip)    # 0x7d9a40
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22691e
leaq 0x38357a(%rip), %rax    # 0x5a9e96
jmp 0x22694d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226932
leaq 0x26e175(%rip), %rax    # 0x494aa5
jmp 0x22694d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226946
leaq 0x75a58(%rip), %rax     # 0x29c39c
jmp 0x22694d
leaq 0x17e80e(%rip), %rax    # 0x3a515b
movq %rax, 0x5b30f4(%rip)    # 0x7d9a48
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2269a7
leaq 0x385be4(%rip), %rax    # 0x5ac589
jmp 0x2269d6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2269bb
leaq 0x27000c(%rip), %rax    # 0x4969c5
jmp 0x2269d6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2269cf
leaq 0x759cf(%rip), %rax     # 0x29c39c
jmp 0x2269d6
leaq 0x180b4e(%rip), %rax    # 0x3a7524
movq %rax, 0x5b3073(%rip)    # 0x7d9a50
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x226a30
leaq 0x388ffc(%rip), %rax    # 0x5afa2a
jmp 0x226a5f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x226a44
leaq 0x2722af(%rip), %rax    # 0x498cf1
jmp 0x226a5f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x226a58
leaq 0x75946(%rip), %rax     # 0x29c39c
jmp 0x226a5f
leaq 0x1836aa(%rip), %rax    # 0x3aa109
movq %rax, 0x5b2ff2(%rip)    # 0x7d9a58
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