LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x244da7
leaq 0x27d3de(%rip), %rax    # 0x4c2183
jmp 0x244dd6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x244dbb
leaq 0x192cd2(%rip), %rax    # 0x3d7a8b
jmp 0x244dd6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x244dcf
leaq 0x54de5(%rip), %rax     # 0x299bb2
jmp 0x244dd6
leaq 0xa11aa(%rip), %rax     # 0x2e5f80
movq %rax, 0x560953(%rip)    # 0x7a5730
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x244e30
leaq 0x27ff9e(%rip), %rax    # 0x4c4dcc
jmp 0x244e5f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x244e44
leaq 0x195909(%rip), %rax    # 0x3da74b
jmp 0x244e5f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x244e58
leaq 0x54d5c(%rip), %rax     # 0x299bb2
jmp 0x244e5f
leaq 0xa433e(%rip), %rax     # 0x2e919d
movq %rax, 0x5608d2(%rip)    # 0x7a5738
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x244eb9
leaq 0x266688(%rip), %rax    # 0x4ab53f
jmp 0x244ee8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x244ecd
leaq 0x17ee7c(%rip), %rax    # 0x3c3d47
jmp 0x244ee8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x244ee1
leaq 0x54cd3(%rip), %rax     # 0x299bb2
jmp 0x244ee8
leaq 0x8afd9(%rip), %rax     # 0x2cfec1
movq %rax, 0x560851(%rip)    # 0x7a5740
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x244f42
leaq 0x26a013(%rip), %rax    # 0x4aef53
jmp 0x244f71
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x244f56
leaq 0x1820c8(%rip), %rax    # 0x3c701c
jmp 0x244f71
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x244f6a
leaq 0x54c4a(%rip), %rax     # 0x299bb2
jmp 0x244f71
leaq 0x8e921(%rip), %rax     # 0x2d3892
movq %rax, 0x5607d0(%rip)    # 0x7a5748
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x244fcb
leaq 0x26dec3(%rip), %rax    # 0x4b2e8c
jmp 0x244ffa
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x244fdf
leaq 0x18577c(%rip), %rax    # 0x3ca759
jmp 0x244ffa
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x244ff3
leaq 0x54bc1(%rip), %rax     # 0x299bb2
jmp 0x244ffa
leaq 0x9237c(%rip), %rax     # 0x2d7376
movq %rax, 0x56074f(%rip)    # 0x7a5750
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x245054
leaq 0x2731c6(%rip), %rax    # 0x4b8218
jmp 0x245083
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x245068
leaq 0x18980c(%rip), %rax    # 0x3ce872
jmp 0x245083
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x24507c
leaq 0x54b38(%rip), %rax     # 0x299bb2
jmp 0x245083
leaq 0x96b57(%rip), %rax     # 0x2dbbda
movq %rax, 0x5606ce(%rip)    # 0x7a5758
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_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 0x2450dd
leaq 0x28395e(%rip), %rax    # 0x4c8a39
jmp 0x24510c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2450f1
leaq 0x197a25(%rip), %rax    # 0x3dcb14
jmp 0x24510c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x245105
leaq 0x5592d(%rip), %rax     # 0x29aa30
jmp 0x24510c
leaq 0xa7672(%rip), %rax     # 0x2ec77e
movq %rax, 0x56064d(%rip)    # 0x7a5760
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_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 0x245166
leaq 0x28586f(%rip), %rax    # 0x4ca9d3
jmp 0x245195
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24517a
leaq 0x199321(%rip), %rax    # 0x3de499
jmp 0x245195
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x24518e
leaq 0x558a4(%rip), %rax     # 0x29aa30
jmp 0x245195
leaq 0xa91cf(%rip), %rax     # 0x2ee364
movq %rax, 0x5605cc(%rip)    # 0x7a5768
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_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 0x2451ef
leaq 0x287683(%rip), %rax    # 0x4cc870
jmp 0x24521e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x245203
leaq 0x19ad57(%rip), %rax    # 0x3dff58
jmp 0x24521e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x245217
leaq 0x5581b(%rip), %rax     # 0x29aa30
jmp 0x24521e
leaq 0xaad14(%rip), %rax     # 0x2eff32
movq %rax, 0x56054b(%rip)    # 0x7a5770
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_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 0x245278
leaq 0x2899a2(%rip), %rax    # 0x4cec18
jmp 0x2452a7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24528c
leaq 0x19cb90(%rip), %rax    # 0x3e1e1a
jmp 0x2452a7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2452a0
leaq 0x55792(%rip), %rax     # 0x29aa30
jmp 0x2452a7
leaq 0xace55(%rip), %rax     # 0x2f20fc
movq %rax, 0x5604ca(%rip)    # 0x7a5778
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x245301
leaq 0x29acf2(%rip), %rax    # 0x4dfff1
jmp 0x245330
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x245315
leaq 0x1a8840(%rip), %rax    # 0x3edb53
jmp 0x245330
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x245329
leaq 0x5488b(%rip), %rax     # 0x299bb2
jmp 0x245330
leaq 0xb9b87(%rip), %rax     # 0x2feeb7
movq %rax, 0x560449(%rip)    # 0x7a5780
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x24538a
leaq 0x29c846(%rip), %rax    # 0x4e1bce
jmp 0x2453b9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24539e
leaq 0x1a9fdd(%rip), %rax    # 0x3ef379
jmp 0x2453b9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2453b2
leaq 0x54802(%rip), %rax     # 0x299bb2
jmp 0x2453b9
leaq 0xbb571(%rip), %rax     # 0x30092a
movq %rax, 0x5603c8(%rip)    # 0x7a5788
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x245413
leaq 0x29e7b4(%rip), %rax    # 0x4e3bc5
jmp 0x245442
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x245427
leaq 0x1ab8c0(%rip), %rax    # 0x3f0ce5
jmp 0x245442
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x24543b
leaq 0x54779(%rip), %rax     # 0x299bb2
jmp 0x245442
leaq 0xbcf19(%rip), %rax     # 0x30235b
movq %rax, 0x560347(%rip)    # 0x7a5790
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_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 0x24549c
leaq 0x2a0dbf(%rip), %rax    # 0x4e6259
jmp 0x2454cb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2454b0
leaq 0x1ad80f(%rip), %rax    # 0x3f2cbd
jmp 0x2454cb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2454c4
leaq 0x546f0(%rip), %rax     # 0x299bb2
jmp 0x2454cb
leaq 0xbf231(%rip), %rax     # 0x3046fc
movq %rax, 0x5602c6(%rip)    # 0x7a5798
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x594f9c
testl %eax, %eax
je 0x245525
leaq 0x28bf37(%rip), %rax    # 0x4d145a
jmp 0x245554
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x245539
leaq 0x19e7ef(%rip), %rax    # 0x3e3d26
jmp 0x245554
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x24554d
leaq 0x54667(%rip), %rax     # 0x299bb2
jmp 0x245554
leaq 0xaeea0(%rip), %rax     # 0x2f43f4
movq %rax, 0x560245(%rip)    # 0x7a57a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x594f9c
testl %eax, %eax
je 0x2455ae
leaq 0x28e672(%rip), %rax    # 0x4d3c1e
jmp 0x2455dd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2455c2
leaq 0x1a04de(%rip), %rax    # 0x3e5a9e
jmp 0x2455dd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2455d6
leaq 0x545de(%rip), %rax     # 0x299bb2
jmp 0x2455dd
leaq 0xb0f1e(%rip), %rax     # 0x2f64fb
movq %rax, 0x5601c4(%rip)    # 0x7a57a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x594f9c
testl %eax, %eax
je 0x245637
leaq 0x291a6d(%rip), %rax    # 0x4d70a2
jmp 0x245666
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24564b
leaq 0x1a2893(%rip), %rax    # 0x3e7edc
jmp 0x245666
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x24565f
leaq 0x54555(%rip), %rax     # 0x299bb2
jmp 0x245666
leaq 0xb357a(%rip), %rax     # 0x2f8be0
movq %rax, 0x560143(%rip)    # 0x7a57b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x594f9c
testl %eax, %eax
je 0x2456c0
leaq 0x296f27(%rip), %rax    # 0x4dc5e5
jmp 0x2456ef
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2456d4
leaq 0x1a5c53(%rip), %rax    # 0x3eb325
jmp 0x2456ef
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2456e8
leaq 0x544cc(%rip), %rax     # 0x299bb2
jmp 0x2456ef
leaq 0xb6d77(%rip), %rax     # 0x2fc466
movq %rax, 0x5600c2(%rip)    # 0x7a57b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x594f9c
testl %eax, %eax
je 0x245749
leaq 0x2a479a(%rip), %rax    # 0x4e9ee1
jmp 0x245778
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24575d
leaq 0x1b0f57(%rip), %rax    # 0x3f66b2
jmp 0x245778
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x245771
leaq 0x552c1(%rip), %rax     # 0x29aa30
jmp 0x245778
leaq 0xc2625(%rip), %rax     # 0x307d9d
movq %rax, 0x560041(%rip)    # 0x7a57c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_stats_table_scan_32_pointer = parasail_sg_qe_de_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_table_scan_32_pointer = parasail_sg_qe_de_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_table_scan_32_pointer = parasail_sg_qe_de_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_table_scan_32_pointer = parasail_sg_qe_de_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_table_scan_32_pointer = parasail_sg_qe_de_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_table_scan_32_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x594f9c
testl %eax, %eax
je 0x2457d2
leaq 0x2a826d(%rip), %rax    # 0x4eda3d
jmp 0x245801
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2457e6
leaq 0x1b43ee(%rip), %rax    # 0x3f9bd2
jmp 0x245801
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2457fa
leaq 0x55238(%rip), %rax     # 0x29aa30
jmp 0x245801
leaq 0xc60a6(%rip), %rax     # 0x30b8a7
movq %rax, 0x55ffc0(%rip)    # 0x7a57c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_de_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_de_stats_table_scan_16_pointer = parasail_sg_qe_de_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_table_scan_16_pointer = parasail_sg_qe_de_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_table_scan_16_pointer = parasail_sg_qe_de_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_table_scan_16_pointer = parasail_sg_qe_de_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_table_scan_16_pointer = parasail_sg_qe_de_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_table_scan_16_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x594f9c
testl %eax, %eax
je 0x24585b
leaq 0x2ac036(%rip), %rax    # 0x4f188f
jmp 0x24588a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x24586f
leaq 0x1b7ae7(%rip), %rax    # 0x3fd354
jmp 0x24588a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x245883
leaq 0x551af(%rip), %rax     # 0x29aa30
jmp 0x24588a
leaq 0xc9bfc(%rip), %rax     # 0x30f486
movq %rax, 0x55ff3f(%rip)    # 0x7a57d0
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