LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1ad5
leaq 0x2efc2c(%rip), %rax    # 0x4b16ff
jmp 0x1c1b04
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1ae9
leaq 0x1f2491(%rip), %rax    # 0x3b3f78
jmp 0x1c1b04
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1afd
leaq 0x7ad61(%rip), %rax     # 0x23c85c
jmp 0x1c1b04
leaq 0xedc4d(%rip), %rax     # 0x2af751
movq %rax, 0x57a975(%rip)    # 0x73c480
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1b5e
leaq 0x2f1caa(%rip), %rax    # 0x4b3806
jmp 0x1c1b8d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1b72
leaq 0x1f4386(%rip), %rax    # 0x3b5ef6
jmp 0x1c1b8d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1b86
leaq 0x7acd8(%rip), %rax     # 0x23c85c
jmp 0x1c1b8d
leaq 0xefef4(%rip), %rax     # 0x2b1a81
movq %rax, 0x57a8f4(%rip)    # 0x73c488
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1be7
leaq 0x2f3fc8(%rip), %rax    # 0x4b5bad
jmp 0x1c1c16
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1bfb
leaq 0x1f6390(%rip), %rax    # 0x3b7f89
jmp 0x1c1c16
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1c0f
leaq 0x7ac4f(%rip), %rax     # 0x23c85c
jmp 0x1c1c16
leaq 0xf1ffc(%rip), %rax     # 0x2b3c12
movq %rax, 0x57a873(%rip)    # 0x73c490
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1c70
leaq 0x2f68cc(%rip), %rax    # 0x4b853a
jmp 0x1c1c9f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1c84
leaq 0x1f8675(%rip), %rax    # 0x3ba2f7
jmp 0x1c1c9f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1c98
leaq 0x7abc6(%rip), %rax     # 0x23c85c
jmp 0x1c1c9f
leaq 0xf44d2(%rip), %rax     # 0x2b6171
movq %rax, 0x57a7f2(%rip)    # 0x73c498
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1cf9
leaq 0x2e09ae(%rip), %rax    # 0x4a26a5
jmp 0x1c1d28
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1d0d
leaq 0x1e7a34(%rip), %rax    # 0x3a973f
jmp 0x1c1d28
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1d21
leaq 0x7ab3d(%rip), %rax     # 0x23c85c
jmp 0x1c1d28
leaq 0xe1cd1(%rip), %rax     # 0x2a39f9
movq %rax, 0x57a771(%rip)    # 0x73c4a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1d82
leaq 0x2e3179(%rip), %rax    # 0x4a4ef9
jmp 0x1c1db1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1d96
leaq 0x1e98d7(%rip), %rax    # 0x3ab66b
jmp 0x1c1db1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1daa
leaq 0x7aab4(%rip), %rax     # 0x23c85c
jmp 0x1c1db1
leaq 0xe3f96(%rip), %rax     # 0x2a5d47
movq %rax, 0x57a6f0(%rip)    # 0x73c4a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1e0b
leaq 0x2e68d7(%rip), %rax    # 0x4a86e0
jmp 0x1c1e3a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1e1f
leaq 0x1ebe90(%rip), %rax    # 0x3adcad
jmp 0x1c1e3a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1e33
leaq 0x7aa2b(%rip), %rax     # 0x23c85c
jmp 0x1c1e3a
leaq 0xe68c7(%rip), %rax     # 0x2a8701
movq %rax, 0x57a66f(%rip)    # 0x73c4b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c1e94
leaq 0x2ec0e3(%rip), %rax    # 0x4adf75
jmp 0x1c1ec3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1ea8
leaq 0x1ef5c3(%rip), %rax    # 0x3b1469
jmp 0x1c1ec3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1ebc
leaq 0x7a9a2(%rip), %rax     # 0x23c85c
jmp 0x1c1ec3
leaq 0xea67f(%rip), %rax     # 0x2ac542
movq %rax, 0x57a5ee(%rip)    # 0x73c4b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_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 0x5672cf
testl %eax, %eax
je 0x1c1f1d
leaq 0x2fa4f3(%rip), %rax    # 0x4bc40e
jmp 0x1c1f4c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1f31
leaq 0x1fc591(%rip), %rax    # 0x3be4c0
jmp 0x1c1f4c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1f45
leaq 0x7b987(%rip), %rax     # 0x23d8ca
jmp 0x1c1f4c
leaq 0xf8579(%rip), %rax     # 0x2ba4c5
movq %rax, 0x57a56d(%rip)    # 0x73c4c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_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 0x5672cf
testl %eax, %eax
je 0x1c1fa6
leaq 0x2fe2e9(%rip), %rax    # 0x4c028d
jmp 0x1c1fd5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c1fba
leaq 0x200079(%rip), %rax    # 0x3c2031
jmp 0x1c1fd5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c1fce
leaq 0x7b8fe(%rip), %rax     # 0x23d8ca
jmp 0x1c1fd5
leaq 0xfc9f3(%rip), %rax     # 0x2be9c8
movq %rax, 0x57a4ec(%rip)    # 0x73c4c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_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 0x5672cf
testl %eax, %eax
je 0x1c202f
leaq 0x302058(%rip), %rax    # 0x4c4085
jmp 0x1c205e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2043
leaq 0x203aa7(%rip), %rax    # 0x3c5ae8
jmp 0x1c205e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2057
leaq 0x7b875(%rip), %rax     # 0x23d8ca
jmp 0x1c205e
leaq 0x1008e3(%rip), %rax    # 0x2c2941
movq %rax, 0x57a46b(%rip)    # 0x73c4d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_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 0x5672cf
testl %eax, %eax
je 0x1c20b8
leaq 0x30635e(%rip), %rax    # 0x4c8414
jmp 0x1c20e7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c20cc
leaq 0x2077d5(%rip), %rax    # 0x3c989f
jmp 0x1c20e7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c20e0
leaq 0x7b7ec(%rip), %rax     # 0x23d8ca
jmp 0x1c20e7
leaq 0x104b02(%rip), %rax    # 0x2c6be9
movq %rax, 0x57a3ea(%rip)    # 0x73c4d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_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 0x5672cf
testl %eax, %eax
je 0x1c2141
leaq 0x31f64d(%rip), %rax    # 0x4e178c
jmp 0x1c2170
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2155
leaq 0x21cc7e(%rip), %rax    # 0x3dedd1
jmp 0x1c2170
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2169
leaq 0x7a6f5(%rip), %rax     # 0x23c85c
jmp 0x1c2170
leaq 0x11cdc1(%rip), %rax    # 0x2def31
movq %rax, 0x57a369(%rip)    # 0x73c4e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c21ca
leaq 0x32352c(%rip), %rax    # 0x4e56f4
jmp 0x1c21f9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c21de
leaq 0x2208f9(%rip), %rax    # 0x3e2ad5
jmp 0x1c21f9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c21f2
leaq 0x7a66c(%rip), %rax     # 0x23c85c
jmp 0x1c21f9
leaq 0x1212f2(%rip), %rax    # 0x2e34eb
movq %rax, 0x57a2e8(%rip)    # 0x73c4e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2253
leaq 0x3275db(%rip), %rax    # 0x4e982c
jmp 0x1c2282
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2267
leaq 0x2246d8(%rip), %rax    # 0x3e693d
jmp 0x1c2282
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c227b
leaq 0x7a5e3(%rip), %rax     # 0x23c85c
jmp 0x1c2282
leaq 0x125434(%rip), %rax    # 0x2e76b6
movq %rax, 0x57a267(%rip)    # 0x73c4f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c22dc
leaq 0x32bceb(%rip), %rax    # 0x4edfc5
jmp 0x1c230b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c22f0
leaq 0x228802(%rip), %rax    # 0x3eaaf0
jmp 0x1c230b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2304
leaq 0x7a55a(%rip), %rax     # 0x23c85c
jmp 0x1c230b
leaq 0x129986(%rip), %rax    # 0x2ebc91
movq %rax, 0x57a1e6(%rip)    # 0x73c4f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2365
leaq 0x30a457(%rip), %rax    # 0x4cc7ba
jmp 0x1c2394
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2379
leaq 0x20b57c(%rip), %rax    # 0x3cd8f3
jmp 0x1c2394
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c238d
leaq 0x7a4d1(%rip), %rax     # 0x23c85c
jmp 0x1c2394
leaq 0x10923a(%rip), %rax    # 0x2cb5ce
movq %rax, 0x57a165(%rip)    # 0x73c500
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c23ee
leaq 0x30e481(%rip), %rax    # 0x4d086d
jmp 0x1c241d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2402
leaq 0x20f069(%rip), %rax    # 0x3d1469
jmp 0x1c241d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2416
leaq 0x7a448(%rip), %rax     # 0x23c85c
jmp 0x1c241d
leaq 0x10d55b(%rip), %rax    # 0x2cf978
movq %rax, 0x57a0e4(%rip)    # 0x73c508
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2477
leaq 0x31348b(%rip), %rax    # 0x4d5900
jmp 0x1c24a6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c248b
leaq 0x2130fc(%rip), %rax    # 0x3d5585
jmp 0x1c24a6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c249f
leaq 0x7a3bf(%rip), %rax     # 0x23c85c
jmp 0x1c24a6
leaq 0x111a5c(%rip), %rax    # 0x2d3f02
movq %rax, 0x57a063(%rip)    # 0x73c510
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x5672cf
testl %eax, %eax
je 0x1c2500
leaq 0x31a084(%rip), %rax    # 0x4dc582
jmp 0x1c252f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2514
leaq 0x218221(%rip), %rax    # 0x3da733
jmp 0x1c252f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c2528
leaq 0x7a336(%rip), %rax     # 0x23c85c
jmp 0x1c252f
leaq 0x117668(%rip), %rax    # 0x2d9b97
movq %rax, 0x579fe2(%rip)    # 0x73c518
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2589
leaq 0x32ec35(%rip), %rax    # 0x4f11bc
jmp 0x1c25b8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c259d
leaq 0x22b1de(%rip), %rax    # 0x3ed779
jmp 0x1c25b8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c25b1
leaq 0x7b31b(%rip), %rax     # 0x23d8ca
jmp 0x1c25b8
leaq 0x12ca68(%rip), %rax    # 0x2ef020
movq %rax, 0x579f61(%rip)    # 0x73c520
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1c2612
leaq 0x330ac1(%rip), %rax    # 0x4f30d1
jmp 0x1c2641
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1c2626
leaq 0x22cea2(%rip), %rax    # 0x3ef4c6
jmp 0x1c2641
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1c263a
leaq 0x7b292(%rip), %rax     # 0x23d8ca
jmp 0x1c2641
leaq 0x12ebfb(%rip), %rax    # 0x2f123c
movq %rax, 0x579ee0(%rip)    # 0x73c528
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