LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x21fb59
leaq 0x318d0c(%rip), %rax    # 0x538863
jmp 0x21fb88
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fb6d
leaq 0x21669b(%rip), %rax    # 0x436206
jmp 0x21fb88
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21fb81
leaq 0x79f38(%rip), %rax     # 0x299ab7
jmp 0x21fb88
leaq 0x12d02b(%rip), %rax    # 0x34cbb3
movq %rax, 0x5839b1(%rip)    # 0x7a3540
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21fbe2
leaq 0x31a788(%rip), %rax    # 0x53a368
jmp 0x21fc11
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fbf6
leaq 0x217ec6(%rip), %rax    # 0x437aba
jmp 0x21fc11
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21fc0a
leaq 0x79eaf(%rip), %rax     # 0x299ab7
jmp 0x21fc11
leaq 0x12e9bb(%rip), %rax    # 0x34e5cc
movq %rax, 0x583930(%rip)    # 0x7a3548
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21fc6b
leaq 0x31c19c(%rip), %rax    # 0x53be05
jmp 0x21fc9a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fc7f
leaq 0x219622(%rip), %rax    # 0x43929f
jmp 0x21fc9a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21fc93
leaq 0x79e26(%rip), %rax     # 0x299ab7
jmp 0x21fc9a
leaq 0x1301dd(%rip), %rax    # 0x34fe77
movq %rax, 0x5838af(%rip)    # 0x7a3550
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21fcf4
leaq 0x31e1f3(%rip), %rax    # 0x53dee5
jmp 0x21fd23
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fd08
leaq 0x21b078(%rip), %rax    # 0x43ad7e
jmp 0x21fd23
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21fd1c
leaq 0x79d9d(%rip), %rax     # 0x299ab7
jmp 0x21fd23
leaq 0x131e6c(%rip), %rax    # 0x351b8f
movq %rax, 0x58382e(%rip)    # 0x7a3558
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21fd7d
leaq 0x308e8d(%rip), %rax    # 0x528c08
jmp 0x21fdac
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fd91
leaq 0x20bf6f(%rip), %rax    # 0x42bcfe
jmp 0x21fdac
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21fda5
leaq 0x79d14(%rip), %rax     # 0x299ab7
jmp 0x21fdac
leaq 0x121dc5(%rip), %rax    # 0x341b71
movq %rax, 0x5837ad(%rip)    # 0x7a3560
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21fe06
leaq 0x30b687(%rip), %rax    # 0x52b48b
jmp 0x21fe35
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fe1a
leaq 0x20dcb7(%rip), %rax    # 0x42dacf
jmp 0x21fe35
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21fe2e
leaq 0x79c8b(%rip), %rax     # 0x299ab7
jmp 0x21fe35
leaq 0x123ebf(%rip), %rax    # 0x343cf4
movq %rax, 0x58372c(%rip)    # 0x7a3568
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21fe8f
leaq 0x30ee63(%rip), %rax    # 0x52ecf0
jmp 0x21febe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21fea3
leaq 0x21018e(%rip), %rax    # 0x43002f
jmp 0x21febe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21feb7
leaq 0x79c02(%rip), %rax     # 0x299ab7
jmp 0x21febe
leaq 0x1265bf(%rip), %rax    # 0x34647d
movq %rax, 0x5836ab(%rip)    # 0x7a3570
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21ff18
leaq 0x314c1a(%rip), %rax    # 0x534b30
jmp 0x21ff47
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ff2c
leaq 0x2139e9(%rip), %rax    # 0x433913
jmp 0x21ff47
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ff40
leaq 0x79b79(%rip), %rax     # 0x299ab7
jmp 0x21ff47
leaq 0x12a0e9(%rip), %rax    # 0x34a030
movq %rax, 0x58362a(%rip)    # 0x7a3578
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21ffa1
leaq 0x321b8f(%rip), %rax    # 0x541b2e
jmp 0x21ffd0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ffb5
leaq 0x21e6cc(%rip), %rax    # 0x43e67f
jmp 0x21ffd0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ffc9
leaq 0x7a96e(%rip), %rax     # 0x29a935
jmp 0x21ffd0
leaq 0x1351dd(%rip), %rax    # 0x3551ad
movq %rax, 0x5835a9(%rip)    # 0x7a3580
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22002a
leaq 0x32579d(%rip), %rax    # 0x5457c5
jmp 0x220059
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22003e
leaq 0x221cb5(%rip), %rax    # 0x441cf1
jmp 0x220059
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220052
leaq 0x7a8e5(%rip), %rax     # 0x29a935
jmp 0x220059
leaq 0x138e69(%rip), %rax    # 0x358ec2
movq %rax, 0x583528(%rip)    # 0x7a3588
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2200b3
leaq 0x3297be(%rip), %rax    # 0x54986f
jmp 0x2200e2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2200c7
leaq 0x225437(%rip), %rax    # 0x4454fc
jmp 0x2200e2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2200db
leaq 0x7a85c(%rip), %rax     # 0x29a935
jmp 0x2200e2
leaq 0x13ca65(%rip), %rax    # 0x35cb47
movq %rax, 0x5834a7(%rip)    # 0x7a3590
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22013c
leaq 0x32d830(%rip), %rax    # 0x54d96a
jmp 0x22016b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220150
leaq 0x229485(%rip), %rax    # 0x4495d3
jmp 0x22016b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220164
leaq 0x7a7d3(%rip), %rax     # 0x29a935
jmp 0x22016b
leaq 0x141066(%rip), %rax    # 0x3611d1
movq %rax, 0x583426(%rip)    # 0x7a3598
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2201c5
leaq 0x3480f6(%rip), %rax    # 0x5682b9
jmp 0x2201f4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2201d9
leaq 0x23ebf3(%rip), %rax    # 0x45edca
jmp 0x2201f4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2201ed
leaq 0x798cc(%rip), %rax     # 0x299ab7
jmp 0x2201f4
leaq 0x158337(%rip), %rax    # 0x37852b
movq %rax, 0x5833a5(%rip)    # 0x7a35a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x22024e
leaq 0x34b868(%rip), %rax    # 0x56bab4
jmp 0x22027d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220262
leaq 0x241e5e(%rip), %rax    # 0x4620be
jmp 0x22027d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220276
leaq 0x79843(%rip), %rax     # 0x299ab7
jmp 0x22027d
leaq 0x15bc75(%rip), %rax    # 0x37bef2
movq %rax, 0x583324(%rip)    # 0x7a35a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2202d7
leaq 0x34f38e(%rip), %rax    # 0x56f663
jmp 0x220306
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2202eb
leaq 0x245242(%rip), %rax    # 0x46552b
jmp 0x220306
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2202ff
leaq 0x797ba(%rip), %rax     # 0x299ab7
jmp 0x220306
leaq 0x15f4af(%rip), %rax    # 0x37f7b5
movq %rax, 0x5832a3(%rip)    # 0x7a35b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x220360
leaq 0x35319e(%rip), %rax    # 0x5734fc
jmp 0x22038f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220374
leaq 0x249064(%rip), %rax    # 0x4693d6
jmp 0x22038f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220388
leaq 0x79731(%rip), %rax     # 0x299ab7
jmp 0x22038f
leaq 0x163731(%rip), %rax    # 0x383ac0
movq %rax, 0x583222(%rip)    # 0x7a35b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2203e9
leaq 0x331d5e(%rip), %rax    # 0x552145
jmp 0x220418
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2203fd
leaq 0x22d153(%rip), %rax    # 0x44d54e
jmp 0x220418
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220411
leaq 0x796a8(%rip), %rax     # 0x299ab7
jmp 0x220418
leaq 0x1453f8(%rip), %rax    # 0x365810
movq %rax, 0x5831a1(%rip)    # 0x7a35c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x220472
leaq 0x336309(%rip), %rax    # 0x556779
jmp 0x2204a1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220486
leaq 0x230f4a(%rip), %rax    # 0x4513ce
jmp 0x2204a1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22049a
leaq 0x7961f(%rip), %rax     # 0x299ab7
jmp 0x2204a1
leaq 0x1496ef(%rip), %rax    # 0x369b90
movq %rax, 0x583120(%rip)    # 0x7a35c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2204fb
leaq 0x33b493(%rip), %rax    # 0x55b98c
jmp 0x22052a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22050f
leaq 0x235308(%rip), %rax    # 0x455815
jmp 0x22052a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220523
leaq 0x79596(%rip), %rax     # 0x299ab7
jmp 0x22052a
leaq 0x14dcf5(%rip), %rax    # 0x36e21f
movq %rax, 0x58309f(%rip)    # 0x7a35d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x220584
leaq 0x342917(%rip), %rax    # 0x562e99
jmp 0x2205b3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220598
leaq 0x23a62b(%rip), %rax    # 0x45abc1
jmp 0x2205b3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2205ac
leaq 0x7950d(%rip), %rax     # 0x299ab7
jmp 0x2205b3
leaq 0x1536a4(%rip), %rax    # 0x373c57
movq %rax, 0x58301e(%rip)    # 0x7a35d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x22060d
leaq 0x3561a6(%rip), %rax    # 0x5767b1
jmp 0x22063c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x220621
leaq 0x24ba46(%rip), %rax    # 0x46c065
jmp 0x22063c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x220635
leaq 0x7a302(%rip), %rax     # 0x29a935
jmp 0x22063c
leaq 0x16648c(%rip), %rax    # 0x386ac8
movq %rax, 0x582f9d(%rip)    # 0x7a35e0
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