LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_scan_8_pointer = parasail_sg_qe_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eafee
leaq 0x6ae69b(%rip), %rax    # 0x899680
movq %rax, 0xc3d3cc(%rip)    # 0xe283b8
jmp 0x1eb038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb00a
leaq 0x3bfaef(%rip), %rax    # 0x5aaaf0
movq %rax, 0xc3d3b0(%rip)    # 0xe283b8
jmp 0x1eb036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb026
leaq 0xe61d3(%rip), %rax     # 0x2d11f0
movq %rax, 0xc3d394(%rip)    # 0xe283b8
jmp 0x1eb034
leaq 0xae273(%rip), %rax     # 0x2992a0
movq %rax, 0xc3d384(%rip)    # 0xe283b8
jmp 0x1eb036
jmp 0x1eb038
movq 0xc3d379(%rip), %rax    # 0xe283b8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_64_pointer = parasail_sg_qe_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb0ae
leaq 0x6e37db(%rip), %rax    # 0x8ce880
movq %rax, 0xc3d314(%rip)    # 0xe283c0
jmp 0x1eb0f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb0ca
leaq 0x3e2aff(%rip), %rax    # 0x5cdbc0
movq %rax, 0xc3d2f8(%rip)    # 0xe283c0
jmp 0x1eb0f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb0e6
leaq 0x109ff3(%rip), %rax    # 0x2f50d0
movq %rax, 0xc3d2dc(%rip)    # 0xe283c0
jmp 0x1eb0f4
leaq 0xac253(%rip), %rax     # 0x297340
movq %rax, 0xc3d2cc(%rip)    # 0xe283c0
jmp 0x1eb0f6
jmp 0x1eb0f8
movq 0xc3d2c1(%rip), %rax    # 0xe283c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_32_pointer = parasail_sg_qe_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb16e
leaq 0x6e8d3b(%rip), %rax    # 0x8d3ea0
movq %rax, 0xc3d25c(%rip)    # 0xe283c8
jmp 0x1eb1b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb18a
leaq 0x3e748f(%rip), %rax    # 0x5d2610
movq %rax, 0xc3d240(%rip)    # 0xe283c8
jmp 0x1eb1b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb1a6
leaq 0x10eb03(%rip), %rax    # 0x2f9ca0
movq %rax, 0xc3d224(%rip)    # 0xe283c8
jmp 0x1eb1b4
leaq 0xac193(%rip), %rax     # 0x297340
movq %rax, 0xc3d214(%rip)    # 0xe283c8
jmp 0x1eb1b6
jmp 0x1eb1b8
movq 0xc3d209(%rip), %rax    # 0xe283c8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_16_pointer = parasail_sg_qe_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb22e
leaq 0x6eebfb(%rip), %rax    # 0x8d9e20
movq %rax, 0xc3d1a4(%rip)    # 0xe283d0
jmp 0x1eb278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb24a
leaq 0x3ec21f(%rip), %rax    # 0x5d7460
movq %rax, 0xc3d188(%rip)    # 0xe283d0
jmp 0x1eb276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb266
leaq 0x113953(%rip), %rax    # 0x2febb0
movq %rax, 0xc3d16c(%rip)    # 0xe283d0
jmp 0x1eb274
leaq 0xac0d3(%rip), %rax     # 0x297340
movq %rax, 0xc3d15c(%rip)    # 0xe283d0
jmp 0x1eb276
jmp 0x1eb278
movq 0xc3d151(%rip), %rax    # 0xe283d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_striped_8_pointer = parasail_sg_qe_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb2ee
leaq 0x6f5d7b(%rip), %rax    # 0x8e1060
movq %rax, 0xc3d0ec(%rip)    # 0xe283d8
jmp 0x1eb338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb30a
leaq 0x3f17ff(%rip), %rax    # 0x5dcb00
movq %rax, 0xc3d0d0(%rip)    # 0xe283d8
jmp 0x1eb336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb326
leaq 0x119233(%rip), %rax    # 0x304550
movq %rax, 0xc3d0b4(%rip)    # 0xe283d8
jmp 0x1eb334
leaq 0xac013(%rip), %rax     # 0x297340
movq %rax, 0xc3d0a4(%rip)    # 0xe283d8
jmp 0x1eb336
jmp 0x1eb338
movq 0xc3d099(%rip), %rax    # 0xe283d8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_64_pointer = parasail_sg_qe_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb3ae
leaq 0x6b655b(%rip), %rax    # 0x8a1900
movq %rax, 0xc3d034(%rip)    # 0xe283e0
jmp 0x1eb3f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb3ca
leaq 0x3c53cf(%rip), %rax    # 0x5b0790
movq %rax, 0xc3d018(%rip)    # 0xe283e0
jmp 0x1eb3f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb3e6
leaq 0xebbf3(%rip), %rax     # 0x2d6fd0
movq %rax, 0xc3cffc(%rip)    # 0xe283e0
jmp 0x1eb3f4
leaq 0xabf53(%rip), %rax     # 0x297340
movq %rax, 0xc3cfec(%rip)    # 0xe283e0
jmp 0x1eb3f6
jmp 0x1eb3f8
movq 0xc3cfe1(%rip), %rax    # 0xe283e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_32_pointer = parasail_sg_qe_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb46e
leaq 0x6be60b(%rip), %rax    # 0x8a9a70
movq %rax, 0xc3cf7c(%rip)    # 0xe283e8
jmp 0x1eb4b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb48a
leaq 0x3caf8f(%rip), %rax    # 0x5b6410
movq %rax, 0xc3cf60(%rip)    # 0xe283e8
jmp 0x1eb4b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb4a6
leaq 0xf19d3(%rip), %rax     # 0x2dce70
movq %rax, 0xc3cf44(%rip)    # 0xe283e8
jmp 0x1eb4b4
leaq 0xabe93(%rip), %rax     # 0x297340
movq %rax, 0xc3cf34(%rip)    # 0xe283e8
jmp 0x1eb4b6
jmp 0x1eb4b8
movq 0xc3cf29(%rip), %rax    # 0xe283e8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_16_pointer = parasail_sg_qe_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb52e
leaq 0x6c94fb(%rip), %rax    # 0x8b4a20
movq %rax, 0xc3cec4(%rip)    # 0xe283f0
jmp 0x1eb578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb54a
leaq 0x3d20bf(%rip), %rax    # 0x5bd600
movq %rax, 0xc3cea8(%rip)    # 0xe283f0
jmp 0x1eb576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb566
leaq 0xf8ce3(%rip), %rax     # 0x2e4240
movq %rax, 0xc3ce8c(%rip)    # 0xe283f0
jmp 0x1eb574
leaq 0xabdd3(%rip), %rax     # 0x297340
movq %rax, 0xc3ce7c(%rip)    # 0xe283f0
jmp 0x1eb576
jmp 0x1eb578
movq 0xc3ce71(%rip), %rax    # 0xe283f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_diag_8_pointer = parasail_sg_qe_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb5ee
leaq 0x6d9beb(%rip), %rax    # 0x8c51d0
movq %rax, 0xc3ce0c(%rip)    # 0xe283f8
jmp 0x1eb638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb60a
leaq 0x3dbadf(%rip), %rax    # 0x5c70e0
movq %rax, 0xc3cdf0(%rip)    # 0xe283f8
jmp 0x1eb636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb626
leaq 0x102d13(%rip), %rax    # 0x2ee330
movq %rax, 0xc3cdd4(%rip)    # 0xe283f8
jmp 0x1eb634
leaq 0xabd13(%rip), %rax     # 0x297340
movq %rax, 0xc3cdc4(%rip)    # 0xe283f8
jmp 0x1eb636
jmp 0x1eb638
movq 0xc3cdb9(%rip), %rax    # 0xe283f8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb6ae
leaq 0x700bbb(%rip), %rax    # 0x8ec260
movq %rax, 0xc3cd54(%rip)    # 0xe28400
jmp 0x1eb6f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb6ca
leaq 0x3fbb3f(%rip), %rax    # 0x5e7200
movq %rax, 0xc3cd38(%rip)    # 0xe28400
jmp 0x1eb6f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb6e6
leaq 0x121683(%rip), %rax    # 0x30cd60
movq %rax, 0xc3cd1c(%rip)    # 0xe28400
jmp 0x1eb6f4
leaq 0xadbb3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3cd0c(%rip)    # 0xe28400
jmp 0x1eb6f6
jmp 0x1eb6f8
movq 0xc3cd01(%rip), %rax    # 0xe28400
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb76e
leaq 0x70ddab(%rip), %rax    # 0x8f9510
movq %rax, 0xc3cc9c(%rip)    # 0xe28408
jmp 0x1eb7b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb78a
leaq 0x4064cf(%rip), %rax    # 0x5f1c50
movq %rax, 0xc3cc80(%rip)    # 0xe28408
jmp 0x1eb7b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb7a6
leaq 0x12b2b3(%rip), %rax    # 0x316a50
movq %rax, 0xc3cc64(%rip)    # 0xe28408
jmp 0x1eb7b4
leaq 0xadaf3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3cc54(%rip)    # 0xe28408
jmp 0x1eb7b6
jmp 0x1eb7b8
movq 0xc3cc49(%rip), %rax    # 0xe28408
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb82e
leaq 0x71c55b(%rip), %rax    # 0x907d80
movq %rax, 0xc3cbe4(%rip)    # 0xe28410
jmp 0x1eb878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb84a
leaq 0x41153f(%rip), %rax    # 0x5fcd80
movq %rax, 0xc3cbc8(%rip)    # 0xe28410
jmp 0x1eb876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb866
leaq 0x135553(%rip), %rax    # 0x320db0
movq %rax, 0xc3cbac(%rip)    # 0xe28410
jmp 0x1eb874
leaq 0xada33(%rip), %rax     # 0x2992a0
movq %rax, 0xc3cb9c(%rip)    # 0xe28410
jmp 0x1eb876
jmp 0x1eb878
movq 0xc3cb91(%rip), %rax    # 0xe28410
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb8ee
leaq 0x72d48b(%rip), %rax    # 0x918d70
movq %rax, 0xc3cb2c(%rip)    # 0xe28418
jmp 0x1eb938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb90a
leaq 0x41d06f(%rip), %rax    # 0x608970
movq %rax, 0xc3cb10(%rip)    # 0xe28418
jmp 0x1eb936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb926
leaq 0x1404c3(%rip), %rax    # 0x32bde0
movq %rax, 0xc3caf4(%rip)    # 0xe28418
jmp 0x1eb934
leaq 0xad973(%rip), %rax     # 0x2992a0
movq %rax, 0xc3cae4(%rip)    # 0xe28418
jmp 0x1eb936
jmp 0x1eb938
movq 0xc3cad9(%rip), %rax    # 0xe28418
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eb9ae
leaq 0x77e0fb(%rip), %rax    # 0x969aa0
movq %rax, 0xc3ca74(%rip)    # 0xe28420
jmp 0x1eb9f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eb9ca
leaq 0x4551ef(%rip), %rax    # 0x640bb0
movq %rax, 0xc3ca58(%rip)    # 0xe28420
jmp 0x1eb9f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eb9e6
leaq 0x1768b3(%rip), %rax    # 0x362290
movq %rax, 0xc3ca3c(%rip)    # 0xe28420
jmp 0x1eb9f4
leaq 0xab953(%rip), %rax     # 0x297340
movq %rax, 0xc3ca2c(%rip)    # 0xe28420
jmp 0x1eb9f6
jmp 0x1eb9f8
movq 0xc3ca21(%rip), %rax    # 0xe28420
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eba6e
leaq 0x788ffb(%rip), %rax    # 0x974a60
movq %rax, 0xc3c9bc(%rip)    # 0xe28428
jmp 0x1ebab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eba8a
leaq 0x45e5cf(%rip), %rax    # 0x64a050
movq %rax, 0xc3c9a0(%rip)    # 0xe28428
jmp 0x1ebab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebaa6
leaq 0x17f593(%rip), %rax    # 0x36b030
movq %rax, 0xc3c984(%rip)    # 0xe28428
jmp 0x1ebab4
leaq 0xab893(%rip), %rax     # 0x297340
movq %rax, 0xc3c974(%rip)    # 0xe28428
jmp 0x1ebab6
jmp 0x1ebab8
movq 0xc3c969(%rip), %rax    # 0xe28428
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_stats_striped_16_pointer = parasail_sg_qe_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ebb2e
leaq 0x794b7b(%rip), %rax    # 0x9806a0
movq %rax, 0xc3c904(%rip)    # 0xe28430
jmp 0x1ebb78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ebb4a
leaq 0x467f7f(%rip), %rax    # 0x653ac0
movq %rax, 0xc3c8e8(%rip)    # 0xe28430
jmp 0x1ebb76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebb66
leaq 0x1886d3(%rip), %rax    # 0x374230
movq %rax, 0xc3c8cc(%rip)    # 0xe28430
jmp 0x1ebb74
leaq 0xab7d3(%rip), %rax     # 0x297340
movq %rax, 0xc3c8bc(%rip)    # 0xe28430
jmp 0x1ebb76
jmp 0x1ebb78
movq 0xc3c8b1(%rip), %rax    # 0xe28430
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ebbee
leaq 0x7a1fcb(%rip), %rax    # 0x98dbb0
movq %rax, 0xc3c84c(%rip)    # 0xe28438
jmp 0x1ebc38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ebc0a
leaq 0x4725cf(%rip), %rax    # 0x65e1d0
movq %rax, 0xc3c830(%rip)    # 0xe28438
jmp 0x1ebc36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebc26
leaq 0x1924f3(%rip), %rax    # 0x37e110
movq %rax, 0xc3c814(%rip)    # 0xe28438
jmp 0x1ebc34
leaq 0xab713(%rip), %rax     # 0x297340
movq %rax, 0xc3c804(%rip)    # 0xe28438
jmp 0x1ebc36
jmp 0x1ebc38
movq 0xc3c7f9(%rip), %rax    # 0xe28438
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ebcae
leaq 0x73b52b(%rip), %rax    # 0x9271d0
movq %rax, 0xc3c794(%rip)    # 0xe28440
jmp 0x1ebcf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ebcca
leaq 0x4271ef(%rip), %rax    # 0x612eb0
movq %rax, 0xc3c778(%rip)    # 0xe28440
jmp 0x1ebcf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebce6
leaq 0x149d43(%rip), %rax    # 0x335a20
movq %rax, 0xc3c75c(%rip)    # 0xe28440
jmp 0x1ebcf4
leaq 0xab653(%rip), %rax     # 0x297340
movq %rax, 0xc3c74c(%rip)    # 0xe28440
jmp 0x1ebcf6
jmp 0x1ebcf8
movq 0xc3c741(%rip), %rax    # 0xe28440
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ebd6e
leaq 0x74856b(%rip), %rax    # 0x9342d0
movq %rax, 0xc3c6dc(%rip)    # 0xe28448
jmp 0x1ebdb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ebd8a
leaq 0x430bcf(%rip), %rax    # 0x61c950
movq %rax, 0xc3c6c0(%rip)    # 0xe28448
jmp 0x1ebdb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebda6
leaq 0x153123(%rip), %rax    # 0x33eec0
movq %rax, 0xc3c6a4(%rip)    # 0xe28448
jmp 0x1ebdb4
leaq 0xab593(%rip), %rax     # 0x297340
movq %rax, 0xc3c694(%rip)    # 0xe28448
jmp 0x1ebdb6
jmp 0x1ebdb8
movq 0xc3c689(%rip), %rax    # 0xe28448
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ebe2e
leaq 0x75888b(%rip), %rax    # 0x9446b0
movq %rax, 0xc3c624(%rip)    # 0xe28450
jmp 0x1ebe78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ebe4a
leaq 0x43bd6f(%rip), %rax    # 0x627bb0
movq %rax, 0xc3c608(%rip)    # 0xe28450
jmp 0x1ebe76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebe66
leaq 0x15dc13(%rip), %rax    # 0x349a70
movq %rax, 0xc3c5ec(%rip)    # 0xe28450
jmp 0x1ebe74
leaq 0xab4d3(%rip), %rax     # 0x297340
movq %rax, 0xc3c5dc(%rip)    # 0xe28450
jmp 0x1ebe76
jmp 0x1ebe78
movq 0xc3c5d1(%rip), %rax    # 0xe28450
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)