LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21b7e9
leaq 0x2f048b(%rip), %rax    # 0x50bc72
jmp 0x21b818
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b7fd
leaq 0x1f4cf8(%rip), %rax    # 0x4104f3
jmp 0x21b818
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b811
leaq 0x7f85b(%rip), %rax     # 0x29b06a
jmp 0x21b818
leaq 0xf1725(%rip), %rax     # 0x30cf3d
movq %rax, 0x5bd801(%rip)    # 0x7d9020
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21b872
leaq 0x2f1ea2(%rip), %rax    # 0x50d712
jmp 0x21b8a1
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b886
leaq 0x1f6563(%rip), %rax    # 0x411de7
jmp 0x21b8a1
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b89a
leaq 0x7f7d2(%rip), %rax     # 0x29b06a
jmp 0x21b8a1
leaq 0xf3476(%rip), %rax     # 0x30ed17
movq %rax, 0x5bd780(%rip)    # 0x7d9028
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21b8fb
leaq 0x2f4a4e(%rip), %rax    # 0x510347
jmp 0x21b92a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b90f
leaq 0x1f8437(%rip), %rax    # 0x413d44
jmp 0x21b92a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b923
leaq 0x7f749(%rip), %rax     # 0x29b06a
jmp 0x21b92a
leaq 0xf5742(%rip), %rax     # 0x31106c
movq %rax, 0x5bd6ff(%rip)    # 0x7d9030
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21b984
leaq 0x2f8ac0(%rip), %rax    # 0x514442
jmp 0x21b9b3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21b998
leaq 0x1fad24(%rip), %rax    # 0x4166ba
jmp 0x21b9b3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21b9ac
leaq 0x7f6c0(%rip), %rax     # 0x29b06a
jmp 0x21b9b3
leaq 0xf890d(%rip), %rax     # 0x3142c0
movq %rax, 0x5bd67e(%rip)    # 0x7d9038
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21ba0d
leaq 0x2e2bc9(%rip), %rax    # 0x4fe5d4
jmp 0x21ba3c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21ba21
leaq 0x1eb2db(%rip), %rax    # 0x406cfa
jmp 0x21ba3c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21ba35
leaq 0x7f637(%rip), %rax     # 0x29b06a
jmp 0x21ba3c
leaq 0xe67bf(%rip), %rax     # 0x3021fb
movq %rax, 0x5bd5fd(%rip)    # 0x7d9040
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21ba96
leaq 0x2e4edc(%rip), %rax    # 0x500970
jmp 0x21bac5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21baaa
leaq 0x1ece3a(%rip), %rax    # 0x4088e2
jmp 0x21bac5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21babe
leaq 0x7f5ae(%rip), %rax     # 0x29b06a
jmp 0x21bac5
leaq 0xe882f(%rip), %rax     # 0x3042f4
movq %rax, 0x5bd57c(%rip)    # 0x7d9048
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21bb1f
leaq 0x2e82d8(%rip), %rax    # 0x503df5
jmp 0x21bb4e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bb33
leaq 0x1ef0cd(%rip), %rax    # 0x40abfe
jmp 0x21bb4e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bb47
leaq 0x7f525(%rip), %rax     # 0x29b06a
jmp 0x21bb4e
leaq 0xead22(%rip), %rax     # 0x306870
movq %rax, 0x5bd4fb(%rip)    # 0x7d9050
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21bba8
leaq 0x2ed2f5(%rip), %rax    # 0x508e9b
jmp 0x21bbd7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bbbc
leaq 0x1f2433(%rip), %rax    # 0x40dfed
jmp 0x21bbd7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bbd0
leaq 0x7f49c(%rip), %rax     # 0x29b06a
jmp 0x21bbd7
leaq 0xee69d(%rip), %rax     # 0x30a274
movq %rax, 0x5bd47a(%rip)    # 0x7d9058
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21bc31
leaq 0x2fbad7(%rip), %rax    # 0x517706
jmp 0x21bc60
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bc45
leaq 0x1fe21b(%rip), %rax    # 0x419e5e
jmp 0x21bc60
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bc59
leaq 0x8070f(%rip), %rax     # 0x29c366
jmp 0x21bc60
leaq 0xfc1fa(%rip), %rax     # 0x317e5a
movq %rax, 0x5bd3f9(%rip)    # 0x7d9060
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21bcba
leaq 0x2ff128(%rip), %rax    # 0x51ade0
jmp 0x21bce9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bcce
leaq 0x20168a(%rip), %rax    # 0x41d356
jmp 0x21bce9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bce2
leaq 0x80686(%rip), %rax     # 0x29c366
jmp 0x21bce9
leaq 0xfff4a(%rip), %rax     # 0x31bc33
movq %rax, 0x5bd378(%rip)    # 0x7d9068
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21bd43
leaq 0x303808(%rip), %rax    # 0x51f549
jmp 0x21bd72
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bd57
leaq 0x2052b1(%rip), %rax    # 0x421006
jmp 0x21bd72
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bd6b
leaq 0x805fd(%rip), %rax     # 0x29c366
jmp 0x21bd72
leaq 0x1043d3(%rip), %rax    # 0x320145
movq %rax, 0x5bd2f7(%rip)    # 0x7d9070
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x21bdcc
leaq 0x308f98(%rip), %rax    # 0x524d62
jmp 0x21bdfb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bde0
leaq 0x209c85(%rip), %rax    # 0x425a63
jmp 0x21bdfb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bdf4
leaq 0x80574(%rip), %rax     # 0x29c366
jmp 0x21bdfb
leaq 0x109a92(%rip), %rax    # 0x32588d
movq %rax, 0x5bd276(%rip)    # 0x7d9078
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x21be55
leaq 0x321e74(%rip), %rax    # 0x53dcc7
jmp 0x21be84
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21be69
leaq 0x21e3c2(%rip), %rax    # 0x43a229
jmp 0x21be84
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21be7d
leaq 0x7f1ef(%rip), %rax     # 0x29b06a
jmp 0x21be84
leaq 0x121146(%rip), %rax    # 0x33cfca
movq %rax, 0x5bd1f5(%rip)    # 0x7d9080
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x21bede
leaq 0x325446(%rip), %rax    # 0x541322
jmp 0x21bf0d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bef2
leaq 0x22175d(%rip), %rax    # 0x43d64d
jmp 0x21bf0d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bf06
leaq 0x7f166(%rip), %rax     # 0x29b06a
jmp 0x21bf0d
leaq 0x124f54(%rip), %rax    # 0x340e61
movq %rax, 0x5bd174(%rip)    # 0x7d9088
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x21bf67
leaq 0x32a468(%rip), %rax    # 0x5463cd
jmp 0x21bf96
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21bf7b
leaq 0x225690(%rip), %rax    # 0x441609
jmp 0x21bf96
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21bf8f
leaq 0x7f0dd(%rip), %rax     # 0x29b06a
jmp 0x21bf96
leaq 0x1293e2(%rip), %rax    # 0x345378
movq %rax, 0x5bd0f3(%rip)    # 0x7d9090
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x21bff0
leaq 0x330607(%rip), %rax    # 0x54c5f5
jmp 0x21c01f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c004
leaq 0x22aa26(%rip), %rax    # 0x446a28
jmp 0x21c01f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c018
leaq 0x7f054(%rip), %rax     # 0x29b06a
jmp 0x21c01f
leaq 0x12f2c0(%rip), %rax    # 0x34b2df
movq %rax, 0x5bd072(%rip)    # 0x7d9098
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x21c079
leaq 0x30ccd3(%rip), %rax    # 0x528d4a
jmp 0x21c0a8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c08d
leaq 0x20d5a7(%rip), %rax    # 0x429632
jmp 0x21c0a8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c0a1
leaq 0x7efcb(%rip), %rax     # 0x29b06a
jmp 0x21c0a8
leaq 0x10df0e(%rip), %rax    # 0x329fb6
movq %rax, 0x5bcff1(%rip)    # 0x7d90a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x21c102
leaq 0x311335(%rip), %rax    # 0x52d435
jmp 0x21c131
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c116
leaq 0x210e03(%rip), %rax    # 0x42cf17
jmp 0x21c131
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c12a
leaq 0x7ef42(%rip), %rax     # 0x29b06a
jmp 0x21c131
leaq 0x1120b4(%rip), %rax    # 0x32e1e5
movq %rax, 0x5bcf70(%rip)    # 0x7d90a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x21c18b
leaq 0x31667c(%rip), %rax    # 0x532805
jmp 0x21c1ba
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c19f
leaq 0x214ea8(%rip), %rax    # 0x431045
jmp 0x21c1ba
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c1b3
leaq 0x7eeb9(%rip), %rax     # 0x29b06a
jmp 0x21c1ba
leaq 0x11649c(%rip), %rax    # 0x332656
movq %rax, 0x5bceef(%rip)    # 0x7d90b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x21c214
leaq 0x31d24b(%rip), %rax    # 0x53945d
jmp 0x21c243
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c228
leaq 0x21a11c(%rip), %rax    # 0x436342
jmp 0x21c243
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c23c
leaq 0x7ee30(%rip), %rax     # 0x29b06a
jmp 0x21c243
leaq 0x11c06a(%rip), %rax    # 0x3382ad
movq %rax, 0x5bce6e(%rip)    # 0x7d90b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21c29d
leaq 0x332c9d(%rip), %rax    # 0x54ef38
jmp 0x21c2cc
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c2b1
leaq 0x22d5ed(%rip), %rax    # 0x44989c
jmp 0x21c2cc
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c2c5
leaq 0x800a3(%rip), %rax     # 0x29c366
jmp 0x21c2cc
leaq 0x13276c(%rip), %rax    # 0x34ea38
movq %rax, 0x5bcded(%rip)    # 0x7d90c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21c326
leaq 0x3347c2(%rip), %rax    # 0x550ae6
jmp 0x21c355
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21c33a
leaq 0x22f0dc(%rip), %rax    # 0x44b414
jmp 0x21c355
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21c34e
leaq 0x8001a(%rip), %rax     # 0x29c366
jmp 0x21c355
leaq 0x13474c(%rip), %rax    # 0x350aa1
movq %rax, 0x5bcd6c(%rip)    # 0x7d90c8
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