LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_diag_16_pointer = parasail_sg_qb_de_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2363af
leaq 0x25b073(%rip), %rax    # 0x491420
jmp 0x2363de
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2363c3
leaq 0x176135(%rip), %rax    # 0x3ac4f6
jmp 0x2363de
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2363d7
leaq 0x63777(%rip), %rax     # 0x299b4c
jmp 0x2363de
leaq 0x801f8(%rip), %rax     # 0x2b65d6
movq %rax, 0x56e5eb(%rip)    # 0x7a49d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_diag_8_pointer = parasail_sg_qb_de_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_diag_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x236438
leaq 0x25e6a0(%rip), %rax    # 0x494ad6
jmp 0x236467
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23644c
leaq 0x178556(%rip), %rax    # 0x3ae9a0
jmp 0x236467
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236460
leaq 0x636ee(%rip), %rax     # 0x299b4c
jmp 0x236467
leaq 0x829f1(%rip), %rax     # 0x2b8e58
movq %rax, 0x56e56a(%rip)    # 0x7a49d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_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_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_64_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2364c1
leaq 0x268454(%rip), %rax    # 0x49e913
jmp 0x2364f0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2364d5
leaq 0x1815eb(%rip), %rax    # 0x3b7abe
jmp 0x2364f0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2364e9
leaq 0x644e3(%rip), %rax     # 0x29a9ca
jmp 0x2364f0
leaq 0x8bf30(%rip), %rax     # 0x2c2420
movq %rax, 0x56e4e9(%rip)    # 0x7a49e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_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_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_32_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23654a
leaq 0x26b82e(%rip), %rax    # 0x4a1d76
jmp 0x236579
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23655e
leaq 0x184616(%rip), %rax    # 0x3bab72
jmp 0x236579
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236572
leaq 0x6445a(%rip), %rax     # 0x29a9ca
jmp 0x236579
leaq 0x8f584(%rip), %rax     # 0x2c5afd
movq %rax, 0x56e468(%rip)    # 0x7a49e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_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_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_16_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2365d3
leaq 0x26e641(%rip), %rax    # 0x4a4c12
jmp 0x236602
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2365e7
leaq 0x1873c8(%rip), %rax    # 0x3bd9ad
jmp 0x236602
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2365fb
leaq 0x643d1(%rip), %rax     # 0x29a9ca
jmp 0x236602
leaq 0x927d0(%rip), %rax     # 0x2c8dd2
movq %rax, 0x56e3e7(%rip)    # 0x7a49f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_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_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_scan_8_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23665c
leaq 0x27147a(%rip), %rax    # 0x4a7ad4
jmp 0x23668b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236670
leaq 0x18a21d(%rip), %rax    # 0x3c088b
jmp 0x23668b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236684
leaq 0x64348(%rip), %rax     # 0x29a9ca
jmp 0x23668b
leaq 0x95be0(%rip), %rax     # 0x2cc26b
movq %rax, 0x56e366(%rip)    # 0x7a49f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_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_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2366e5
leaq 0x285e7c(%rip), %rax    # 0x4bc55f
jmp 0x236714
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2366f9
leaq 0x19b904(%rip), %rax    # 0x3d1ffb
jmp 0x236714
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23670d
leaq 0x63441(%rip), %rax     # 0x299b4c
jmp 0x236714
leaq 0xa93c6(%rip), %rax     # 0x2dfada
movq %rax, 0x56e2e5(%rip)    # 0x7a4a00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_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_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23676e
leaq 0x288e01(%rip), %rax    # 0x4bf56d
jmp 0x23679d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236782
leaq 0x19e689(%rip), %rax    # 0x3d4e09
jmp 0x23679d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236796
leaq 0x633b8(%rip), %rax     # 0x299b4c
jmp 0x23679d
leaq 0xac7ad(%rip), %rax     # 0x2e2f4a
movq %rax, 0x56e264(%rip)    # 0x7a4a08
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_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_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2367f7
leaq 0x28b928(%rip), %rax    # 0x4c211d
jmp 0x236826
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23680b
leaq 0x1a121c(%rip), %rax    # 0x3d7a25
jmp 0x236826
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23681f
leaq 0x6332f(%rip), %rax     # 0x299b4c
jmp 0x236826
leaq 0xaf6f4(%rip), %rax     # 0x2e5f1a
movq %rax, 0x56e1e3(%rip)    # 0x7a4a10
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_striped_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x236880
leaq 0x28e4e8(%rip), %rax    # 0x4c4d66
jmp 0x2368af
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236894
leaq 0x1a3e53(%rip), %rax    # 0x3da6e5
jmp 0x2368af
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2368a8
leaq 0x632a6(%rip), %rax     # 0x299b4c
jmp 0x2368af
leaq 0xb2888(%rip), %rax     # 0x2e9137
movq %rax, 0x56e162(%rip)    # 0x7a4a18
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x236909
leaq 0x274bd2(%rip), %rax    # 0x4ab4d9
jmp 0x236938
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23691d
leaq 0x18d3c6(%rip), %rax    # 0x3c3ce1
jmp 0x236938
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236931
leaq 0x6321d(%rip), %rax     # 0x299b4c
jmp 0x236938
leaq 0x99523(%rip), %rax     # 0x2cfe5b
movq %rax, 0x56e0e1(%rip)    # 0x7a4a20
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x236992
leaq 0x27855d(%rip), %rax    # 0x4aeeed
jmp 0x2369c1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2369a6
leaq 0x190612(%rip), %rax    # 0x3c6fb6
jmp 0x2369c1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2369ba
leaq 0x63194(%rip), %rax     # 0x299b4c
jmp 0x2369c1
leaq 0x9ce6b(%rip), %rax     # 0x2d382c
movq %rax, 0x56e060(%rip)    # 0x7a4a28
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x236a1b
leaq 0x27c40d(%rip), %rax    # 0x4b2e26
jmp 0x236a4a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236a2f
leaq 0x193cc6(%rip), %rax    # 0x3ca6f3
jmp 0x236a4a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236a43
leaq 0x6310b(%rip), %rax     # 0x299b4c
jmp 0x236a4a
leaq 0xa08c6(%rip), %rax     # 0x2d7310
movq %rax, 0x56dfdf(%rip)    # 0x7a4a30
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_stats_diag_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x236aa4
leaq 0x281710(%rip), %rax    # 0x4b81b2
jmp 0x236ad3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236ab8
leaq 0x197d56(%rip), %rax    # 0x3ce80c
jmp 0x236ad3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236acc
leaq 0x63082(%rip), %rax     # 0x299b4c
jmp 0x236ad3
leaq 0xa50a1(%rip), %rax     # 0x2dbb74
movq %rax, 0x56df5e(%rip)    # 0x7a4a38
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_64_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236b2d
leaq 0x291ea8(%rip), %rax    # 0x4c89d3
jmp 0x236b5c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236b41
leaq 0x1a5f6f(%rip), %rax    # 0x3dcaae
jmp 0x236b5c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236b55
leaq 0x63e77(%rip), %rax     # 0x29a9ca
jmp 0x236b5c
leaq 0xb5bbc(%rip), %rax     # 0x2ec718
movq %rax, 0x56dedd(%rip)    # 0x7a4a40
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_32_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236bb6
leaq 0x293db9(%rip), %rax    # 0x4ca96d
jmp 0x236be5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236bca
leaq 0x1a786b(%rip), %rax    # 0x3de433
jmp 0x236be5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236bde
leaq 0x63dee(%rip), %rax     # 0x29a9ca
jmp 0x236be5
leaq 0xb7719(%rip), %rax     # 0x2ee2fe
movq %rax, 0x56de5c(%rip)    # 0x7a4a48
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_16_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236c3f
leaq 0x295bcd(%rip), %rax    # 0x4cc80a
jmp 0x236c6e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236c53
leaq 0x1a92a1(%rip), %rax    # 0x3dfef2
jmp 0x236c6e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236c67
leaq 0x63d65(%rip), %rax     # 0x29a9ca
jmp 0x236c6e
leaq 0xb925e(%rip), %rax     # 0x2efecc
movq %rax, 0x56dddb(%rip)    # 0x7a4a50
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_scan_8_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236cc8
leaq 0x297eec(%rip), %rax    # 0x4cebb2
jmp 0x236cf7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236cdc
leaq 0x1ab0da(%rip), %rax    # 0x3e1db4
jmp 0x236cf7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236cf0
leaq 0x63cdc(%rip), %rax     # 0x29a9ca
jmp 0x236cf7
leaq 0xbb39f(%rip), %rax     # 0x2f2096
movq %rax, 0x56dd5a(%rip)    # 0x7a4a58
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_striped_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236d51
leaq 0x2a923c(%rip), %rax    # 0x4dff8b
jmp 0x236d80
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236d65
leaq 0x1b6d8a(%rip), %rax    # 0x3edaed
jmp 0x236d80
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236d79
leaq 0x62dd5(%rip), %rax     # 0x299b4c
jmp 0x236d80
leaq 0xc80d1(%rip), %rax     # 0x2fee51
movq %rax, 0x56dcd9(%rip)    # 0x7a4a60
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_striped_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236dda
leaq 0x2aad90(%rip), %rax    # 0x4e1b68
jmp 0x236e09
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236dee
leaq 0x1b8527(%rip), %rax    # 0x3ef313
jmp 0x236e09
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236e02
leaq 0x62d4c(%rip), %rax     # 0x299b4c
jmp 0x236e09
leaq 0xc9abb(%rip), %rax     # 0x3008c4
movq %rax, 0x56dc58(%rip)    # 0x7a4a68
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_striped_16_pointer = parasail_sg_qb_de_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_striped_16_pointer = parasail_sg_qb_de_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_striped_16_pointer = parasail_sg_qb_de_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_striped_16_pointer = parasail_sg_qb_de_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_striped_16_pointer = parasail_sg_qb_de_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_striped_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236e63
leaq 0x2accfe(%rip), %rax    # 0x4e3b5f
jmp 0x236e92
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236e77
leaq 0x1b9e0a(%rip), %rax    # 0x3f0c7f
jmp 0x236e92
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236e8b
leaq 0x62cc3(%rip), %rax     # 0x299b4c
jmp 0x236e92
leaq 0xcb463(%rip), %rax     # 0x3022f5
movq %rax, 0x56dbd7(%rip)    # 0x7a4a70
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_de_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_de_table_striped_8_pointer = parasail_sg_qb_de_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_table_striped_8_pointer = parasail_sg_qb_de_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_table_striped_8_pointer = parasail_sg_qb_de_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_table_striped_8_pointer = parasail_sg_qb_de_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_table_striped_8_pointer = parasail_sg_qb_de_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_table_striped_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_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 0x594f9c
testl %eax, %eax
je 0x236eec
leaq 0x2af309(%rip), %rax    # 0x4e61f3
jmp 0x236f1b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x236f00
leaq 0x1bbd59(%rip), %rax    # 0x3f2c57
jmp 0x236f1b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x236f14
leaq 0x62c3a(%rip), %rax     # 0x299b4c
jmp 0x236f1b
leaq 0xcd77b(%rip), %rax     # 0x304696
movq %rax, 0x56db56(%rip)    # 0x7a4a78
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