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_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_profile_64_pointer = parasail_sg_qe_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_profile_64_pointer = parasail_sg_qe_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_profile_64_pointer = parasail_sg_qe_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_profile_64_pointer = parasail_sg_qe_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_profile_64_pointer = parasail_sg_qe_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ef7a6
leaq 0x7aa6a3(%rip), %rax    # 0x999e40
movq %rax, 0xc38f1c(%rip)    # 0xe286c0
jmp 0x1ef7ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef7c2
leaq 0x4765e7(%rip), %rax    # 0x665da0
movq %rax, 0xc38f00(%rip)    # 0xe286c0
jmp 0x1ef7ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef7de
leaq 0x1985fb(%rip), %rax    # 0x387dd0
movq %rax, 0xc38ee4(%rip)    # 0xe286c0
jmp 0x1ef7e8
movq $0x0, -0x8(%rbp)
jmp 0x1ef80b
jmp 0x1ef7ea
jmp 0x1ef7ec
movq 0xc38ecd(%rip), %rax    # 0xe286c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_profile_32_pointer = parasail_sg_qe_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_profile_32_pointer = parasail_sg_qe_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_profile_32_pointer = parasail_sg_qe_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_profile_32_pointer = parasail_sg_qe_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_profile_32_pointer = parasail_sg_qe_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ef856
leaq 0x7b1013(%rip), %rax    # 0x9a0860
movq %rax, 0xc38e74(%rip)    # 0xe286c8
jmp 0x1ef89c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef872
leaq 0x47ba87(%rip), %rax    # 0x66b2f0
movq %rax, 0xc38e58(%rip)    # 0xe286c8
jmp 0x1ef89a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef88e
leaq 0x19dd3b(%rip), %rax    # 0x38d5c0
movq %rax, 0xc38e3c(%rip)    # 0xe286c8
jmp 0x1ef898
movq $0x0, -0x8(%rbp)
jmp 0x1ef8bb
jmp 0x1ef89a
jmp 0x1ef89c
movq 0xc38e25(%rip), %rax    # 0xe286c8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_profile_16_pointer = parasail_sg_qe_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_profile_16_pointer = parasail_sg_qe_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_profile_16_pointer = parasail_sg_qe_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_profile_16_pointer = parasail_sg_qe_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_profile_16_pointer = parasail_sg_qe_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ef906
leaq 0x7b8ce3(%rip), %rax    # 0x9a85e0
movq %rax, 0xc38dcc(%rip)    # 0xe286d0
jmp 0x1ef94c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef922
leaq 0x481647(%rip), %rax    # 0x670f60
movq %rax, 0xc38db0(%rip)    # 0xe286d0
jmp 0x1ef94a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef93e
leaq 0x1a3a8b(%rip), %rax    # 0x3933c0
movq %rax, 0xc38d94(%rip)    # 0xe286d0
jmp 0x1ef948
movq $0x0, -0x8(%rbp)
jmp 0x1ef96b
jmp 0x1ef94a
jmp 0x1ef94c
movq 0xc38d7d(%rip), %rax    # 0xe286d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_profile_8_pointer = parasail_sg_qe_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_profile_8_pointer = parasail_sg_qe_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_profile_8_pointer = parasail_sg_qe_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_profile_8_pointer = parasail_sg_qe_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_profile_8_pointer = parasail_sg_qe_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ef9b6
leaq 0x7c2e63(%rip), %rax    # 0x9b2810
movq %rax, 0xc38d24(%rip)    # 0xe286d8
jmp 0x1ef9fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ef9d2
leaq 0x487e67(%rip), %rax    # 0x677830
movq %rax, 0xc38d08(%rip)    # 0xe286d8
jmp 0x1ef9fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ef9ee
leaq 0x1aa62b(%rip), %rax    # 0x39a010
movq %rax, 0xc38cec(%rip)    # 0xe286d8
jmp 0x1ef9f8
movq $0x0, -0x8(%rbp)
jmp 0x1efa1b
jmp 0x1ef9fa
jmp 0x1ef9fc
movq 0xc38cd5(%rip), %rax    # 0xe286d8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_profile_64_pointer = parasail_sg_qe_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_profile_64_pointer = parasail_sg_qe_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_profile_64_pointer = parasail_sg_qe_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_profile_64_pointer = parasail_sg_qe_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_profile_64_pointer = parasail_sg_qe_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1efa66
leaq 0x7fdf33(%rip), %rax    # 0x9ed990
movq %rax, 0xc38c7c(%rip)    # 0xe286e0
jmp 0x1efaac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1efa82
leaq 0x4adc47(%rip), %rax    # 0x69d6c0
movq %rax, 0xc38c60(%rip)    # 0xe286e0
jmp 0x1efaaa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1efa9e
leaq 0x1d141b(%rip), %rax    # 0x3c0eb0
movq %rax, 0xc38c44(%rip)    # 0xe286e0
jmp 0x1efaa8
movq $0x0, -0x8(%rbp)
jmp 0x1efacb
jmp 0x1efaaa
jmp 0x1efaac
movq 0xc38c2d(%rip), %rax    # 0xe286e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_profile_32_pointer = parasail_sg_qe_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_profile_32_pointer = parasail_sg_qe_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_profile_32_pointer = parasail_sg_qe_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_profile_32_pointer = parasail_sg_qe_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_profile_32_pointer = parasail_sg_qe_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1efb16
leaq 0x803a93(%rip), %rax    # 0x9f35a0
movq %rax, 0xc38bd4(%rip)    # 0xe286e8
jmp 0x1efb5c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1efb32
leaq 0x4b2957(%rip), %rax    # 0x6a2480
movq %rax, 0xc38bb8(%rip)    # 0xe286e8
jmp 0x1efb5a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1efb4e
leaq 0x1d636b(%rip), %rax    # 0x3c5eb0
movq %rax, 0xc38b9c(%rip)    # 0xe286e8
jmp 0x1efb58
movq $0x0, -0x8(%rbp)
jmp 0x1efb7b
jmp 0x1efb5a
jmp 0x1efb5c
movq 0xc38b85(%rip), %rax    # 0xe286e8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_profile_16_pointer = parasail_sg_qe_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_profile_16_pointer = parasail_sg_qe_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_profile_16_pointer = parasail_sg_qe_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_profile_16_pointer = parasail_sg_qe_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_profile_16_pointer = parasail_sg_qe_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1efbc6
leaq 0x80a453(%rip), %rax    # 0x9fa010
movq %rax, 0xc38b2c(%rip)    # 0xe286f0
jmp 0x1efc0c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1efbe2
leaq 0x4b7c77(%rip), %rax    # 0x6a7850
movq %rax, 0xc38b10(%rip)    # 0xe286f0
jmp 0x1efc0a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1efbfe
leaq 0x1db79b(%rip), %rax    # 0x3cb390
movq %rax, 0xc38af4(%rip)    # 0xe286f0
jmp 0x1efc08
movq $0x0, -0x8(%rbp)
jmp 0x1efc2b
jmp 0x1efc0a
jmp 0x1efc0c
movq 0xc38add(%rip), %rax    # 0xe286f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_profile_8_pointer = parasail_sg_qe_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_profile_8_pointer = parasail_sg_qe_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_profile_8_pointer = parasail_sg_qe_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_profile_8_pointer = parasail_sg_qe_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_profile_8_pointer = parasail_sg_qe_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_table_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1efc76
leaq 0x812b63(%rip), %rax    # 0xa027d0
movq %rax, 0xc38a84(%rip)    # 0xe286f8
jmp 0x1efcbc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1efc92
leaq 0x4bdc97(%rip), %rax    # 0x6ad920
movq %rax, 0xc38a68(%rip)    # 0xe286f8
jmp 0x1efcba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1efcae
leaq 0x1e1b2b(%rip), %rax    # 0x3d17d0
movq %rax, 0xc38a4c(%rip)    # 0xe286f8
jmp 0x1efcb8
movq $0x0, -0x8(%rbp)
jmp 0x1efcdb
jmp 0x1efcba
jmp 0x1efcbc
movq 0xc38a35(%rip), %rax    # 0xe286f8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_profile_64_pointer = parasail_sg_qe_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_profile_64_pointer = parasail_sg_qe_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_profile_64_pointer = parasail_sg_qe_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_profile_64_pointer = parasail_sg_qe_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_profile_64_pointer = parasail_sg_qe_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1efd26
leaq 0x81e9e3(%rip), %rax    # 0xa0e700
movq %rax, 0xc389dc(%rip)    # 0xe28700
jmp 0x1efd6c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1efd42
leaq 0x4c8cf7(%rip), %rax    # 0x6b8a30
movq %rax, 0xc389c0(%rip)    # 0xe28700
jmp 0x1efd6a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1efd5e
leaq 0x1ea9fb(%rip), %rax    # 0x3da750
movq %rax, 0xc389a4(%rip)    # 0xe28700
jmp 0x1efd68
movq $0x0, -0x8(%rbp)
jmp 0x1efd8b
jmp 0x1efd6a
jmp 0x1efd6c
movq 0xc3898d(%rip), %rax    # 0xe28700
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_profile_32_pointer = parasail_sg_qe_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_profile_32_pointer = parasail_sg_qe_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_profile_32_pointer = parasail_sg_qe_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_profile_32_pointer = parasail_sg_qe_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_profile_32_pointer = parasail_sg_qe_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1efdd6
leaq 0x82c363(%rip), %rax    # 0xa1c130
movq %rax, 0xc38934(%rip)    # 0xe28708
jmp 0x1efe1c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1efdf2
leaq 0x4d3b87(%rip), %rax    # 0x6c3970
movq %rax, 0xc38918(%rip)    # 0xe28708
jmp 0x1efe1a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1efe0e
leaq 0x1f4bdb(%rip), %rax    # 0x3e49e0
movq %rax, 0xc388fc(%rip)    # 0xe28708
jmp 0x1efe18
movq $0x0, -0x8(%rbp)
jmp 0x1efe3b
jmp 0x1efe1a
jmp 0x1efe1c
movq 0xc388e5(%rip), %rax    # 0xe28708
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_profile_16_pointer = parasail_sg_qe_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_profile_16_pointer = parasail_sg_qe_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_profile_16_pointer = parasail_sg_qe_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_profile_16_pointer = parasail_sg_qe_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_profile_16_pointer = parasail_sg_qe_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1efe86
leaq 0x83b7a3(%rip), %rax    # 0xa2b620
movq %rax, 0xc3888c(%rip)    # 0xe28710
jmp 0x1efecc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1efea2
leaq 0x4df2f7(%rip), %rax    # 0x6cf190
movq %rax, 0xc38870(%rip)    # 0xe28710
jmp 0x1efeca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1efebe
leaq 0x1ff5cb(%rip), %rax    # 0x3ef480
movq %rax, 0xc38854(%rip)    # 0xe28710
jmp 0x1efec8
movq $0x0, -0x8(%rbp)
jmp 0x1efeeb
jmp 0x1efeca
jmp 0x1efecc
movq 0xc3883d(%rip), %rax    # 0xe28710
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_profile_8_pointer = parasail_sg_qe_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_profile_8_pointer = parasail_sg_qe_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_profile_8_pointer = parasail_sg_qe_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_profile_8_pointer = parasail_sg_qe_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_profile_8_pointer = parasail_sg_qe_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eff36
leaq 0x84dd83(%rip), %rax    # 0xa3dcb0
movq %rax, 0xc387e4(%rip)    # 0xe28718
jmp 0x1eff7c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eff52
leaq 0x4eb9a7(%rip), %rax    # 0x6db8f0
movq %rax, 0xc387c8(%rip)    # 0xe28718
jmp 0x1eff7a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eff6e
leaq 0x20b11b(%rip), %rax    # 0x3fb080
movq %rax, 0xc387ac(%rip)    # 0xe28718
jmp 0x1eff78
movq $0x0, -0x8(%rbp)
jmp 0x1eff9b
jmp 0x1eff7a
jmp 0x1eff7c
movq 0xc38795(%rip), %rax    # 0xe28718
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_striped_profile_64_pointer = parasail_sg_qe_stats_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_profile_64_pointer = parasail_sg_qe_stats_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_profile_64_pointer = parasail_sg_qe_stats_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_profile_64_pointer = parasail_sg_qe_stats_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_profile_64_pointer = parasail_sg_qe_stats_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1effe6
leaq 0x8a5683(%rip), %rax    # 0xa95660
movq %rax, 0xc3873c(%rip)    # 0xe28720
jmp 0x1f002c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f0002
leaq 0x527457(%rip), %rax    # 0x717450
movq %rax, 0xc38720(%rip)    # 0xe28720
jmp 0x1f002a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f001e
leaq 0x24506b(%rip), %rax    # 0x435080
movq %rax, 0xc38704(%rip)    # 0xe28720
jmp 0x1f0028
movq $0x0, -0x8(%rbp)
jmp 0x1f004b
jmp 0x1f002a
jmp 0x1f002c
movq 0xc386ed(%rip), %rax    # 0xe28720
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_striped_profile_32_pointer = parasail_sg_qe_stats_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_profile_32_pointer = parasail_sg_qe_stats_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_profile_32_pointer = parasail_sg_qe_stats_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_profile_32_pointer = parasail_sg_qe_stats_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_profile_32_pointer = parasail_sg_qe_stats_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f0096
leaq 0x8b0ef3(%rip), %rax    # 0xaa0f80
movq %rax, 0xc38694(%rip)    # 0xe28728
jmp 0x1f00dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f00b2
leaq 0x530eb7(%rip), %rax    # 0x720f60
movq %rax, 0xc38678(%rip)    # 0xe28728
jmp 0x1f00da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f00ce
leaq 0x24e49b(%rip), %rax    # 0x43e560
movq %rax, 0xc3865c(%rip)    # 0xe28728
jmp 0x1f00d8
movq $0x0, -0x8(%rbp)
jmp 0x1f00fb
jmp 0x1f00da
jmp 0x1f00dc
movq 0xc38645(%rip), %rax    # 0xe28728
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_striped_profile_16_pointer = parasail_sg_qe_stats_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_profile_16_pointer = parasail_sg_qe_stats_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_profile_16_pointer = parasail_sg_qe_stats_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_profile_16_pointer = parasail_sg_qe_stats_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_profile_16_pointer = parasail_sg_qe_stats_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f0146
leaq 0x8bd8e3(%rip), %rax    # 0xaada20
movq %rax, 0xc385ec(%rip)    # 0xe28730
jmp 0x1f018c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f0162
leaq 0x53b0f7(%rip), %rax    # 0x72b250
movq %rax, 0xc385d0(%rip)    # 0xe28730
jmp 0x1f018a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f017e
leaq 0x257ebb(%rip), %rax    # 0x448030
movq %rax, 0xc385b4(%rip)    # 0xe28730
jmp 0x1f0188
movq $0x0, -0x8(%rbp)
jmp 0x1f01ab
jmp 0x1f018a
jmp 0x1f018c
movq 0xc3859d(%rip), %rax    # 0xe28730
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_striped_profile_8_pointer = parasail_sg_qe_stats_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_profile_8_pointer = parasail_sg_qe_stats_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_profile_8_pointer = parasail_sg_qe_stats_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_profile_8_pointer = parasail_sg_qe_stats_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_profile_8_pointer = parasail_sg_qe_stats_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_stats_table_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f01f6
leaq 0x8cc673(%rip), %rax    # 0xabc860
movq %rax, 0xc38544(%rip)    # 0xe28738
jmp 0x1f023c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f0212
leaq 0x5464b7(%rip), %rax    # 0x7366c0
movq %rax, 0xc38528(%rip)    # 0xe28738
jmp 0x1f023a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f022e
leaq 0x262abb(%rip), %rax    # 0x452ce0
movq %rax, 0xc3850c(%rip)    # 0xe28738
jmp 0x1f0238
movq $0x0, -0x8(%rbp)
jmp 0x1f025b
jmp 0x1f023a
jmp 0x1f023c
movq 0xc384f5(%rip), %rax    # 0xe28738
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_profile_64_pointer = parasail_sg_qe_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_profile_64_pointer = parasail_sg_qe_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_profile_64_pointer = parasail_sg_qe_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_profile_64_pointer = parasail_sg_qe_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_profile_64_pointer = parasail_sg_qe_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_rowcol_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f02a6
leaq 0x8d6483(%rip), %rax    # 0xac6720
movq %rax, 0xc3849c(%rip)    # 0xe28740
jmp 0x1f02ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f02c2
leaq 0x54e0e7(%rip), %rax    # 0x73e3a0
movq %rax, 0xc38480(%rip)    # 0xe28740
jmp 0x1f02ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f02de
leaq 0x26a3bb(%rip), %rax    # 0x45a690
movq %rax, 0xc38464(%rip)    # 0xe28740
jmp 0x1f02e8
movq $0x0, -0x8(%rbp)
jmp 0x1f030b
jmp 0x1f02ea
jmp 0x1f02ec
movq 0xc3844d(%rip), %rax    # 0xe28740
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_profile_32_pointer = parasail_sg_qe_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_profile_32_pointer = parasail_sg_qe_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_profile_32_pointer = parasail_sg_qe_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_profile_32_pointer = parasail_sg_qe_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_profile_32_pointer = parasail_sg_qe_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_rowcol_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f0356
leaq 0x8dcfa3(%rip), %rax    # 0xacd2f0
movq %rax, 0xc383f4(%rip)    # 0xe28748
jmp 0x1f039c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f0372
leaq 0x553787(%rip), %rax    # 0x743af0
movq %rax, 0xc383d8(%rip)    # 0xe28748
jmp 0x1f039a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f038e
leaq 0x26fcfb(%rip), %rax    # 0x460080
movq %rax, 0xc383bc(%rip)    # 0xe28748
jmp 0x1f0398
movq $0x0, -0x8(%rbp)
jmp 0x1f03bb
jmp 0x1f039a
jmp 0x1f039c
movq 0xc383a5(%rip), %rax    # 0xe28748
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_profile_16_pointer = parasail_sg_qe_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_profile_16_pointer = parasail_sg_qe_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_profile_16_pointer = parasail_sg_qe_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_profile_16_pointer = parasail_sg_qe_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_profile_16_pointer = parasail_sg_qe_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_rowcol_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f0406
leaq 0x8e4ce3(%rip), %rax    # 0xad50e0
movq %rax, 0xc3834c(%rip)    # 0xe28750
jmp 0x1f044c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f0422
leaq 0x5594c7(%rip), %rax    # 0x7498e0
movq %rax, 0xc38330(%rip)    # 0xe28750
jmp 0x1f044a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f043e
leaq 0x275bbb(%rip), %rax    # 0x465ff0
movq %rax, 0xc38314(%rip)    # 0xe28750
jmp 0x1f0448
movq $0x0, -0x8(%rbp)
jmp 0x1f046b
jmp 0x1f044a
jmp 0x1f044c
movq 0xc382fd(%rip), %rax    # 0xe28750
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_profile_8_pointer = parasail_sg_qe_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_profile_8_pointer = parasail_sg_qe_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_profile_8_pointer = parasail_sg_qe_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_profile_8_pointer = parasail_sg_qe_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_profile_8_pointer = parasail_sg_qe_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qe_rowcol_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f04b6
leaq 0x8eec23(%rip), %rax    # 0xadf0d0
movq %rax, 0xc382a4(%rip)    # 0xe28758
jmp 0x1f04fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f04d2
leaq 0x55fd37(%rip), %rax    # 0x750200
movq %rax, 0xc38288(%rip)    # 0xe28758
jmp 0x1f04fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f04ee
leaq 0x27c74b(%rip), %rax    # 0x46cc30
movq %rax, 0xc3826c(%rip)    # 0xe28758
jmp 0x1f04f8
movq $0x0, -0x8(%rbp)
jmp 0x1f051b
jmp 0x1f04fa
jmp 0x1f04fc
movq 0xc38255(%rip), %rax    # 0xe28758
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)