LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_striped_8_pointer = parasail_sg_qe_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_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 0x21ffa8
leaq 0x2d0793(%rip), %rax    # 0x4f0739
jmp 0x21ffd7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ffbc
leaq 0x1dc962(%rip), %rax    # 0x3fc91c
jmp 0x21ffd7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ffd0
leaq 0x7b0b7(%rip), %rax     # 0x29b085
jmp 0x21ffd7
leaq 0xd4c01(%rip), %rax     # 0x2f4bd8
movq %rax, 0x5b945a(%rip)    # 0x7d9438
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_diag_64_pointer = parasail_sg_qe_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_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 0x220031
leaq 0x2b5e50(%rip), %rax    # 0x4d5e7f
jmp 0x220060
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220045
leaq 0x1c547b(%rip), %rax    # 0x3e54be
jmp 0x220060
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220059
leaq 0x7b02e(%rip), %rax     # 0x29b085
jmp 0x220060
leaq 0xb946c(%rip), %rax     # 0x2d94cc
movq %rax, 0x5b93d9(%rip)    # 0x7d9440
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_diag_32_pointer = parasail_sg_qe_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_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 0x2200ba
leaq 0x2b93c8(%rip), %rax    # 0x4d9480
jmp 0x2200e9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2200ce
leaq 0x1c8557(%rip), %rax    # 0x3e8623
jmp 0x2200e9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2200e2
leaq 0x7afa5(%rip), %rax     # 0x29b085
jmp 0x2200e9
leaq 0xbce73(%rip), %rax     # 0x2dcf5c
movq %rax, 0x5b9358(%rip)    # 0x7d9448
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_diag_16_pointer = parasail_sg_qe_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_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 0x220143
leaq 0x2bd313(%rip), %rax    # 0x4dd454
jmp 0x220172
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220157
leaq 0x1cbbd9(%rip), %rax    # 0x3ebd2e
jmp 0x220172
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22016b
leaq 0x7af1c(%rip), %rax     # 0x29b085
jmp 0x220172
leaq 0xc0808(%rip), %rax     # 0x2e097a
movq %rax, 0x5b92d7(%rip)    # 0x7d9450
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_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_diag_8_pointer = parasail_sg_qe_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_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 0x2201cc
leaq 0x2c209e(%rip), %rax    # 0x4e2268
jmp 0x2201fb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2201e0
leaq 0x1cfbec(%rip), %rax    # 0x3efdca
jmp 0x2201fb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2201f4
leaq 0x7ae93(%rip), %rax     # 0x29b085
jmp 0x2201fb
leaq 0xc53ad(%rip), %rax     # 0x2e55a8
movq %rax, 0x5b9256(%rip)    # 0x7d9458
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_qe_dispatch.c
// Function: parasail_sg_qe_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_scan_64_pointer = parasail_sg_qe_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x220255
leaq 0x2d3968(%rip), %rax    # 0x4f3bbb
jmp 0x220284
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220269
leaq 0x1de920(%rip), %rax    # 0x3feb87
jmp 0x220284
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22027d
leaq 0x7c106(%rip), %rax     # 0x29c381
jmp 0x220284
leaq 0xd848d(%rip), %rax     # 0x2f8711
movq %rax, 0x5b91d5(%rip)    # 0x7d9460
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_qe_dispatch.c
// Function: parasail_sg_qe_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_scan_32_pointer = parasail_sg_qe_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x2202de
leaq 0x2d55a2(%rip), %rax    # 0x4f587e
jmp 0x22030d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2202f2
leaq 0x1e042e(%rip), %rax    # 0x40071e
jmp 0x22030d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220306
leaq 0x7c07d(%rip), %rax     # 0x29c381
jmp 0x22030d
leaq 0xda460(%rip), %rax     # 0x2fa76d
movq %rax, 0x5b9154(%rip)    # 0x7d9468
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_qe_dispatch.c
// Function: parasail_sg_qe_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_scan_16_pointer = parasail_sg_qe_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x220367
leaq 0x2d80f8(%rip), %rax    # 0x4f845d
jmp 0x220396
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22037b
leaq 0x1e23e8(%rip), %rax    # 0x402761
jmp 0x220396
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22038f
leaq 0x7bff4(%rip), %rax     # 0x29c381
jmp 0x220396
leaq 0xdc869(%rip), %rax     # 0x2fcbff
movq %rax, 0x5b90d3(%rip)    # 0x7d9470
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_qe_dispatch.c
// Function: parasail_sg_qe_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_scan_8_pointer = parasail_sg_qe_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x2203f0
leaq 0x2dbf0b(%rip), %rax    # 0x4fc2f9
jmp 0x22041f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220404
leaq 0x1e4b58(%rip), %rax    # 0x404f5a
jmp 0x22041f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220418
leaq 0x7bf6b(%rip), %rax     # 0x29c381
jmp 0x22041f
leaq 0xdf92b(%rip), %rax     # 0x2ffd4a
movq %rax, 0x5b9052(%rip)    # 0x7d9478
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_qe_dispatch.c
// Function: parasail_sg_qe_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_striped_64_pointer = parasail_sg_qe_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x220479
leaq 0x2eb816(%rip), %rax    # 0x50bc8d
jmp 0x2204a8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22048d
leaq 0x1f0083(%rip), %rax    # 0x41050e
jmp 0x2204a8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2204a1
leaq 0x7abe6(%rip), %rax     # 0x29b085
jmp 0x2204a8
leaq 0xecab0(%rip), %rax     # 0x30cf58
movq %rax, 0x5b8fd1(%rip)    # 0x7d9480
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_qe_dispatch.c
// Function: parasail_sg_qe_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_striped_32_pointer = parasail_sg_qe_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x220502
leaq 0x2ed22d(%rip), %rax    # 0x50d72d
jmp 0x220531
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220516
leaq 0x1f18ee(%rip), %rax    # 0x411e02
jmp 0x220531
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22052a
leaq 0x7ab5d(%rip), %rax     # 0x29b085
jmp 0x220531
leaq 0xee801(%rip), %rax     # 0x30ed32
movq %rax, 0x5b8f50(%rip)    # 0x7d9488
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_qe_dispatch.c
// Function: parasail_sg_qe_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_striped_16_pointer = parasail_sg_qe_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x22058b
leaq 0x2efdd9(%rip), %rax    # 0x510362
jmp 0x2205ba
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22059f
leaq 0x1f37c2(%rip), %rax    # 0x413d5f
jmp 0x2205ba
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2205b3
leaq 0x7aad4(%rip), %rax     # 0x29b085
jmp 0x2205ba
leaq 0xf0acd(%rip), %rax     # 0x311087
movq %rax, 0x5b8ecf(%rip)    # 0x7d9490
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_qe_dispatch.c
// Function: parasail_sg_qe_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_table_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_table_striped_8_pointer = parasail_sg_qe_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x220614
leaq 0x2f3e4b(%rip), %rax    # 0x51445d
jmp 0x220643
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220628
leaq 0x1f60af(%rip), %rax    # 0x4166d5
jmp 0x220643
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22063c
leaq 0x7aa4b(%rip), %rax     # 0x29b085
jmp 0x220643
leaq 0xf3c98(%rip), %rax     # 0x3142db
movq %rax, 0x5b8e4e(%rip)    # 0x7d9498
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_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x22069d
leaq 0x2ddf54(%rip), %rax    # 0x4fe5ef
jmp 0x2206cc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2206b1
leaq 0x1e6666(%rip), %rax    # 0x406d15
jmp 0x2206cc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2206c5
leaq 0x7a9c2(%rip), %rax     # 0x29b085
jmp 0x2206cc
leaq 0xe1b4a(%rip), %rax     # 0x302216
movq %rax, 0x5b8dcd(%rip)    # 0x7d94a0
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_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x220726
leaq 0x2e0267(%rip), %rax    # 0x50098b
jmp 0x220755
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22073a
leaq 0x1e81c5(%rip), %rax    # 0x4088fd
jmp 0x220755
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x22074e
leaq 0x7a939(%rip), %rax     # 0x29b085
jmp 0x220755
leaq 0xe3bba(%rip), %rax     # 0x30430f
movq %rax, 0x5b8d4c(%rip)    # 0x7d94a8
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_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2207af
leaq 0x2e3663(%rip), %rax    # 0x503e10
jmp 0x2207de
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2207c3
leaq 0x1ea458(%rip), %rax    # 0x40ac19
jmp 0x2207de
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2207d7
leaq 0x7a8b0(%rip), %rax     # 0x29b085
jmp 0x2207de
leaq 0xe60ad(%rip), %rax     # 0x30688b
movq %rax, 0x5b8ccb(%rip)    # 0x7d94b0
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_qe_dispatch.c
// Function: parasail_sg_qe_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x220838
leaq 0x2e8680(%rip), %rax    # 0x508eb6
jmp 0x220867
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22084c
leaq 0x1ed7be(%rip), %rax    # 0x40e008
jmp 0x220867
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220860
leaq 0x7a827(%rip), %rax     # 0x29b085
jmp 0x220867
leaq 0xe9a28(%rip), %rax     # 0x30a28f
movq %rax, 0x5b8c4a(%rip)    # 0x7d94b8
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_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_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x2208c1
leaq 0x2f6e62(%rip), %rax    # 0x517721
jmp 0x2208f0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2208d5
leaq 0x1f95a6(%rip), %rax    # 0x419e79
jmp 0x2208f0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2208e9
leaq 0x7ba9a(%rip), %rax     # 0x29c381
jmp 0x2208f0
leaq 0xf7585(%rip), %rax     # 0x317e75
movq %rax, 0x5b8bc9(%rip)    # 0x7d94c0
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_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_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x22094a
leaq 0x2fa4b3(%rip), %rax    # 0x51adfb
jmp 0x220979
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x22095e
leaq 0x1fca15(%rip), %rax    # 0x41d371
jmp 0x220979
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220972
leaq 0x7ba11(%rip), %rax     # 0x29c381
jmp 0x220979
leaq 0xfb2d5(%rip), %rax     # 0x31bc4e
movq %rax, 0x5b8b48(%rip)    # 0x7d94c8
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_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_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x2209d3
leaq 0x2feb93(%rip), %rax    # 0x51f564
jmp 0x220a02
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2209e7
leaq 0x20063c(%rip), %rax    # 0x421021
jmp 0x220a02
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2209fb
leaq 0x7b988(%rip), %rax     # 0x29c381
jmp 0x220a02
leaq 0xff75e(%rip), %rax     # 0x320160
movq %rax, 0x5b8ac7(%rip)    # 0x7d94d0
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_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_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x220a5c
leaq 0x304323(%rip), %rax    # 0x524d7d
jmp 0x220a8b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220a70
leaq 0x205010(%rip), %rax    # 0x425a7e
jmp 0x220a8b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220a84
leaq 0x7b8ff(%rip), %rax     # 0x29c381
jmp 0x220a8b
leaq 0x104e1d(%rip), %rax    # 0x3258a8
movq %rax, 0x5b8a46(%rip)    # 0x7d94d8
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_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_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_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_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 0x220ae5
leaq 0x31d1ff(%rip), %rax    # 0x53dce2
jmp 0x220b14
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x220af9
leaq 0x21974d(%rip), %rax    # 0x43a244
jmp 0x220b14
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x220b0d
leaq 0x7a57a(%rip), %rax     # 0x29b085
jmp 0x220b14
leaq 0x11c4d1(%rip), %rax    # 0x33cfe5
movq %rax, 0x5b89c5(%rip)    # 0x7d94e0
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