LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21c3af
leaq 0x3370fa(%rip), %rax    # 0x5534a7
jmp 0x21c3de
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c3c3
leaq 0x230eda(%rip), %rax    # 0x44d29b
jmp 0x21c3de
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c3d7
leaq 0x7ff91(%rip), %rax     # 0x29c366
jmp 0x21c3de
leaq 0x136a39(%rip), %rax    # 0x352e17
movq %rax, 0x5bcceb(%rip)    # 0x7d90d0
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21c438
leaq 0x33ad95(%rip), %rax    # 0x5571cb
jmp 0x21c467
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c44c
leaq 0x23342c(%rip), %rax    # 0x44f876
jmp 0x21c467
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c460
leaq 0x7ff08(%rip), %rax     # 0x29c366
jmp 0x21c467
leaq 0x13988b(%rip), %rax    # 0x355cf2
movq %rax, 0x5bcc6a(%rip)    # 0x7d90d8
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c4c1
leaq 0x34b093(%rip), %rax    # 0x567552
jmp 0x21c4f0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c4d5
leaq 0x23ee22(%rip), %rax    # 0x45b2f5
jmp 0x21c4f0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c4e9
leaq 0x7eb83(%rip), %rax     # 0x29b06a
jmp 0x21c4f0
leaq 0x146e7c(%rip), %rax    # 0x36336c
movq %rax, 0x5bcbe9(%rip)    # 0x7d90e0
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c54a
leaq 0x34c8d2(%rip), %rax    # 0x568e1a
jmp 0x21c579
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c55e
leaq 0x240617(%rip), %rax    # 0x45cb73
jmp 0x21c579
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c572
leaq 0x7eafa(%rip), %rax     # 0x29b06a
jmp 0x21c579
leaq 0x148b4d(%rip), %rax    # 0x3650c6
movq %rax, 0x5bcb68(%rip)    # 0x7d90e8
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c5d3
leaq 0x34eef8(%rip), %rax    # 0x56b4c9
jmp 0x21c602
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c5e7
leaq 0x24219b(%rip), %rax    # 0x45e780
jmp 0x21c602
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c5fb
leaq 0x7ea71(%rip), %rax     # 0x29b06a
jmp 0x21c602
leaq 0x14aafc(%rip), %rax    # 0x3670fe
movq %rax, 0x5bcae7(%rip)    # 0x7d90f0
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c65c
leaq 0x352931(%rip), %rax    # 0x56ef8b
jmp 0x21c68b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c670
leaq 0x244476(%rip), %rax    # 0x460ae4
jmp 0x21c68b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c684
leaq 0x7e9e8(%rip), %rax     # 0x29b06a
jmp 0x21c68b
leaq 0x14d5db(%rip), %rax    # 0x369c66
movq %rax, 0x5bca66(%rip)    # 0x7d90f8
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c6e5
leaq 0x33cde7(%rip), %rax    # 0x5594ca
jmp 0x21c714
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c6f9
leaq 0x234f38(%rip), %rax    # 0x45162f
jmp 0x21c714
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c70d
leaq 0x7e95f(%rip), %rax     # 0x29b06a
jmp 0x21c714
leaq 0x13ba12(%rip), %rax    # 0x358126
movq %rax, 0x5bc9e5(%rip)    # 0x7d9100
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c76e
leaq 0x33f220(%rip), %rax    # 0x55b98c
jmp 0x21c79d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c782
leaq 0x236af2(%rip), %rax    # 0x453272
jmp 0x21c79d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c796
leaq 0x7e8d6(%rip), %rax     # 0x29b06a
jmp 0x21c79d
leaq 0x13dae0(%rip), %rax    # 0x35a27d
movq %rax, 0x5bc964(%rip)    # 0x7d9108
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c7f7
leaq 0x3428c0(%rip), %rax    # 0x55f0b5
jmp 0x21c826
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c80b
leaq 0x238eaf(%rip), %rax    # 0x4556b8
jmp 0x21c826
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c81f
leaq 0x7e84d(%rip), %rax     # 0x29b06a
jmp 0x21c826
leaq 0x14013c(%rip), %rax    # 0x35c962
movq %rax, 0x5bc8e3(%rip)    # 0x7d9110
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_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21c880
leaq 0x347e71(%rip), %rax    # 0x5646ef
jmp 0x21c8af
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c894
leaq 0x23c4de(%rip), %rax    # 0x458d70
jmp 0x21c8af
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c8a8
leaq 0x7e7c4(%rip), %rax     # 0x29b06a
jmp 0x21c8af
leaq 0x143d42(%rip), %rax    # 0x3605f1
movq %rax, 0x5bc862(%rip)    # 0x7d9118
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21c909
leaq 0x3557be(%rip), %rax    # 0x5720c5
jmp 0x21c938
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c91d
leaq 0x247812(%rip), %rax    # 0x46412d
jmp 0x21c938
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c931
leaq 0x7fa37(%rip), %rax     # 0x29c366
jmp 0x21c938
leaq 0x150cb2(%rip), %rax    # 0x36d5ea
movq %rax, 0x5bc7e1(%rip)    # 0x7d9120
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21c992
leaq 0x358fc5(%rip), %rax    # 0x575955
jmp 0x21c9c1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c9a6
leaq 0x24ad48(%rip), %rax    # 0x4676ec
jmp 0x21c9c1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c9ba
leaq 0x7f9ae(%rip), %rax     # 0x29c366
jmp 0x21c9c1
leaq 0x154b23(%rip), %rax    # 0x3714e4
movq %rax, 0x5bc760(%rip)    # 0x7d9128
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21ca1b
leaq 0x35d937(%rip), %rax    # 0x57a350
jmp 0x21ca4a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ca2f
leaq 0x24ea6b(%rip), %rax    # 0x46b498
jmp 0x21ca4a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ca43
leaq 0x7f925(%rip), %rax     # 0x29c366
jmp 0x21ca4a
leaq 0x159025(%rip), %rax    # 0x375a6f
movq %rax, 0x5bc6df(%rip)    # 0x7d9130
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21caa4
leaq 0x362d21(%rip), %rax    # 0x57f7c3
jmp 0x21cad3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21cab8
leaq 0x253491(%rip), %rax    # 0x46ff47
jmp 0x21cad3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21cacc
leaq 0x7f89c(%rip), %rax     # 0x29c366
jmp 0x21cad3
leaq 0x15e638(%rip), %rax    # 0x37b10b
movq %rax, 0x5bc65e(%rip)    # 0x7d9138
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21cb2d
leaq 0x37b9f3(%rip), %rax    # 0x59851e
jmp 0x21cb5c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21cb41
leaq 0x2683bd(%rip), %rax    # 0x484efc
jmp 0x21cb5c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21cb55
leaq 0x7e517(%rip), %rax     # 0x29b06a
jmp 0x21cb5c
leaq 0x176283(%rip), %rax    # 0x392ddf
movq %rax, 0x5bc5dd(%rip)    # 0x7d9140
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21cbb6
leaq 0x37edb2(%rip), %rax    # 0x59b966
jmp 0x21cbe5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21cbca
leaq 0x26b609(%rip), %rax    # 0x4881d1
jmp 0x21cbe5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21cbde
leaq 0x7e48e(%rip), %rax     # 0x29b06a
jmp 0x21cbe5
leaq 0x179fa7(%rip), %rax    # 0x396b8c
movq %rax, 0x5bc55c(%rip)    # 0x7d9148
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21cc3f
leaq 0x38350e(%rip), %rax    # 0x5a014b
jmp 0x21cc6e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21cc53
leaq 0x26eefc(%rip), %rax    # 0x48bb4d
jmp 0x21cc6e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21cc67
leaq 0x7e405(%rip), %rax     # 0x29b06a
jmp 0x21cc6e
leaq 0x17df33(%rip), %rax    # 0x39aba1
movq %rax, 0x5bc4db(%rip)    # 0x7d9150
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21ccc8
leaq 0x388c90(%rip), %rax    # 0x5a5956
jmp 0x21ccf7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ccdc
leaq 0x273608(%rip), %rax    # 0x4902e2
jmp 0x21ccf7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ccf0
leaq 0x7e37c(%rip), %rax     # 0x29b06a
jmp 0x21ccf7
leaq 0x182fcc(%rip), %rax    # 0x39fcc3
movq %rax, 0x5bc45a(%rip)    # 0x7d9158
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21cd51
leaq 0x366bc7(%rip), %rax    # 0x583916
jmp 0x21cd80
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21cd65
leaq 0x256f98(%rip), %rax    # 0x473cfb
jmp 0x21cd80
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21cd79
leaq 0x7e2f3(%rip), %rax     # 0x29b06a
jmp 0x21cd80
leaq 0x162b1f(%rip), %rax    # 0x37f89f
movq %rax, 0x5bc3d9(%rip)    # 0x7d9160
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21cdda
leaq 0x36ac2d(%rip), %rax    # 0x587a05
jmp 0x21ce09
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21cdee
leaq 0x25aaec(%rip), %rax    # 0x4778d8
jmp 0x21ce09
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ce02
leaq 0x7e26a(%rip), %rax     # 0x29b06a
jmp 0x21ce09
leaq 0x166f34(%rip), %rax    # 0x383d3d
movq %rax, 0x5bc358(%rip)    # 0x7d9168
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21ce63
leaq 0x36fde6(%rip), %rax    # 0x58cc47
jmp 0x21ce92
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ce77
leaq 0x25ed50(%rip), %rax    # 0x47bbc5
jmp 0x21ce92
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ce8b
leaq 0x7e1e1(%rip), %rax     # 0x29b06a
jmp 0x21ce92
leaq 0x16b49c(%rip), %rax    # 0x38832e
movq %rax, 0x5bc2d7(%rip)    # 0x7d9170
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