LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c269b
leaq 0x332b60(%rip), %rax    # 0x4f51f9
jmp 0x1c26ca
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c26af
leaq 0x22eca2(%rip), %rax    # 0x3f134f
jmp 0x1c26ca
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c26c3
leaq 0x7b209(%rip), %rax     # 0x23d8ca
jmp 0x1c26ca
leaq 0x130b6f(%rip), %rax    # 0x2f3239
movq %rax, 0x579e5f(%rip)    # 0x73c530
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2724
leaq 0x33512c(%rip), %rax    # 0x4f784e
jmp 0x1c2753
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2738
leaq 0x230ce8(%rip), %rax    # 0x3f341e
jmp 0x1c2753
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c274c
leaq 0x7b180(%rip), %rax     # 0x23d8ca
jmp 0x1c2753
leaq 0x132e81(%rip), %rax    # 0x2f55d4
movq %rax, 0x579dde(%rip)    # 0x73c538
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c27ad
leaq 0x34705f(%rip), %rax    # 0x50980a
jmp 0x1c27dc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c27c1
leaq 0x23d776(%rip), %rax    # 0x3fff35
jmp 0x1c27dc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c27d5
leaq 0x7a089(%rip), %rax     # 0x23c85c
jmp 0x1c27dc
leaq 0x14167f(%rip), %rax    # 0x303e5b
movq %rax, 0x579d5d(%rip)    # 0x73c540
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2836
leaq 0x348cd9(%rip), %rax    # 0x50b50d
jmp 0x1c2865
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c284a
leaq 0x23f2d4(%rip), %rax    # 0x401b1c
jmp 0x1c2865
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c285e
leaq 0x7a000(%rip), %rax     # 0x23c85c
jmp 0x1c2865
leaq 0x143646(%rip), %rax    # 0x305eab
movq %rax, 0x579cdc(%rip)    # 0x73c548
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c28bf
leaq 0x34aae5(%rip), %rax    # 0x50d3a2
jmp 0x1c28ee
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c28d3
leaq 0x240e62(%rip), %rax    # 0x403733
jmp 0x1c28ee
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c28e7
leaq 0x79f77(%rip), %rax     # 0x23c85c
jmp 0x1c28ee
leaq 0x145312(%rip), %rax    # 0x307c00
movq %rax, 0x579c5b(%rip)    # 0x73c550
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2948
leaq 0x34ceb8(%rip), %rax    # 0x50f7fe
jmp 0x1c2977
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c295c
leaq 0x242c8c(%rip), %rax    # 0x4055e6
jmp 0x1c2977
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2970
leaq 0x79eee(%rip), %rax     # 0x23c85c
jmp 0x1c2977
leaq 0x1473ec(%rip), %rax    # 0x309d63
movq %rax, 0x579bda(%rip)    # 0x73c558
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c29d1
leaq 0x337685(%rip), %rax    # 0x4fa054
jmp 0x1c2a00
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c29e5
leaq 0x232bae(%rip), %rax    # 0x3f5591
jmp 0x1c2a00
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c29f9
leaq 0x79e65(%rip), %rax     # 0x23c85c
jmp 0x1c2a00
leaq 0x1353e8(%rip), %rax    # 0x2f7de8
movq %rax, 0x579b59(%rip)    # 0x73c560
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2a5a
leaq 0x339dfb(%rip), %rax    # 0x4fc853
jmp 0x1c2a89
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2a6e
leaq 0x2349e1(%rip), %rax    # 0x3f744d
jmp 0x1c2a89
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2a82
leaq 0x79ddc(%rip), %rax     # 0x23c85c
jmp 0x1c2a89
leaq 0x13769f(%rip), %rax    # 0x2fa128
movq %rax, 0x579ad8(%rip)    # 0x73c568
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2ae3
leaq 0x33d6c3(%rip), %rax    # 0x5001a4
jmp 0x1c2b12
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2af7
leaq 0x236fb9(%rip), %rax    # 0x3f9aae
jmp 0x1c2b12
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2b0b
leaq 0x79d53(%rip), %rax     # 0x23c85c
jmp 0x1c2b12
leaq 0x139fa1(%rip), %rax    # 0x2fcab3
movq %rax, 0x579a57(%rip)    # 0x73c570
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2b6c
leaq 0x3433d4(%rip), %rax    # 0x505f3e
jmp 0x1c2b9b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2b80
leaq 0x23a7af(%rip), %rax    # 0x3fd32d
jmp 0x1c2b9b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2b94
leaq 0x79cca(%rip), %rax     # 0x23c85c
jmp 0x1c2b9b
leaq 0x13df40(%rip), %rax    # 0x300adb
movq %rax, 0x5799d6(%rip)    # 0x73c578
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2bf5
leaq 0x350bfe(%rip), %rax    # 0x5137f1
jmp 0x1c2c24
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2c09
leaq 0x246afc(%rip), %rax    # 0x409703
jmp 0x1c2c24
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2c1d
leaq 0x7acaf(%rip), %rax     # 0x23d8ca
jmp 0x1c2c24
leaq 0x14b47a(%rip), %rax    # 0x30e09e
movq %rax, 0x579955(%rip)    # 0x73c580
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2c7e
leaq 0x354b80(%rip), %rax    # 0x5177fc
jmp 0x1c2cad
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2c92
leaq 0x24a736(%rip), %rax    # 0x40d3c6
jmp 0x1c2cad
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2ca6
leaq 0x7ac26(%rip), %rax     # 0x23d8ca
jmp 0x1c2cad
leaq 0x14fa14(%rip), %rax    # 0x3126c1
movq %rax, 0x5798d4(%rip)    # 0x73c588
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2d07
leaq 0x3587b6(%rip), %rax    # 0x51b4bb
jmp 0x1c2d36
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2d1b
leaq 0x24e19e(%rip), %rax    # 0x410eb7
jmp 0x1c2d36
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2d2f
leaq 0x7ab9d(%rip), %rax     # 0x23d8ca
jmp 0x1c2d36
leaq 0x153901(%rip), %rax    # 0x316637
movq %rax, 0x579853(%rip)    # 0x73c590
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2d90
leaq 0x35c7de(%rip), %rax    # 0x51f56c
jmp 0x1c2dbf
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2da4
leaq 0x251e31(%rip), %rax    # 0x414bd3
jmp 0x1c2dbf
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2db8
leaq 0x7ab14(%rip), %rax     # 0x23d8ca
jmp 0x1c2dbf
leaq 0x157b25(%rip), %rax    # 0x31a8e4
movq %rax, 0x5797d2(%rip)    # 0x73c598
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2e19
leaq 0x3760a5(%rip), %rax    # 0x538ebc
jmp 0x1c2e48
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2e2d
leaq 0x26758b(%rip), %rax    # 0x42a3b6
jmp 0x1c2e48
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2e41
leaq 0x79a1d(%rip), %rax     # 0x23c85c
jmp 0x1c2e48
leaq 0x17017c(%rip), %rax    # 0x332fc4
movq %rax, 0x579751(%rip)    # 0x73c5a0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2ea2
leaq 0x379b46(%rip), %rax    # 0x53c9e6
jmp 0x1c2ed1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2eb6
leaq 0x26af39(%rip), %rax    # 0x42dded
jmp 0x1c2ed1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2eca
leaq 0x79994(%rip), %rax     # 0x23c85c
jmp 0x1c2ed1
leaq 0x174393(%rip), %rax    # 0x337264
movq %rax, 0x5796d0(%rip)    # 0x73c5a8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2f2b
leaq 0x37d4d8(%rip), %rax    # 0x540401
jmp 0x1c2f5a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2f3f
leaq 0x26e6fc(%rip), %rax    # 0x431639
jmp 0x1c2f5a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2f53
leaq 0x7990b(%rip), %rax     # 0x23c85c
jmp 0x1c2f5a
leaq 0x178008(%rip), %rax    # 0x33af62
movq %rax, 0x57964f(%rip)    # 0x73c5b0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2fb4
leaq 0x381381(%rip), %rax    # 0x544333
jmp 0x1c2fe3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2fc8
leaq 0x27218c(%rip), %rax    # 0x435152
jmp 0x1c2fe3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2fdc
leaq 0x79882(%rip), %rax     # 0x23c85c
jmp 0x1c2fe3
leaq 0x17bf71(%rip), %rax    # 0x33ef54
movq %rax, 0x5795ce(%rip)    # 0x73c5b8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c303d
leaq 0x360870(%rip), %rax    # 0x5238ab
jmp 0x1c306c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3051
leaq 0x255c10(%rip), %rax    # 0x418c5f
jmp 0x1c306c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3065
leaq 0x797f9(%rip), %rax     # 0x23c85c
jmp 0x1c306c
leaq 0x15c2db(%rip), %rax    # 0x31f347
movq %rax, 0x57954d(%rip)    # 0x73c5c0
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c30c6
leaq 0x364946(%rip), %rax    # 0x527a0a
jmp 0x1c30f5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c30da
leaq 0x2597a2(%rip), %rax    # 0x41c87a
jmp 0x1c30f5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c30ee
leaq 0x79770(%rip), %rax     # 0x23c85c
jmp 0x1c30f5
leaq 0x160696(%rip), %rax    # 0x32378b
movq %rax, 0x5794cc(%rip)    # 0x73c5c8
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_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c314f
leaq 0x369b21(%rip), %rax    # 0x52cc6e
jmp 0x1c317e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c3163
leaq 0x25d8fc(%rip), %rax    # 0x420a5d
jmp 0x1c317e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c3177
leaq 0x796e7(%rip), %rax     # 0x23c85c
jmp 0x1c317e
leaq 0x164c4c(%rip), %rax    # 0x327dca
movq %rax, 0x57944b(%rip)    # 0x73c5d0
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