LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x1f752e
leaq 0xa7536b(%rip), %rax    # 0xc6c890
movq %rax, 0xc3153c(%rip)    # 0xe28a68
jmp 0x1f7578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f754a
leaq 0x67131f(%rip), %rax    # 0x868860
movq %rax, 0xc31520(%rip)    # 0xe28a68
jmp 0x1f7576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7566
leaq 0x388b13(%rip), %rax    # 0x580070
movq %rax, 0xc31504(%rip)    # 0xe28a68
jmp 0x1f7574
leaq 0x9fe43(%rip), %rax     # 0x2973b0
movq %rax, 0xc314f4(%rip)    # 0xe28a68
jmp 0x1f7576
jmp 0x1f7578
movq 0xc314e9(%rip), %rax    # 0xe28a68
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x1f75ee
leaq 0xa80bdb(%rip), %rax    # 0xc781c0
movq %rax, 0xc31484(%rip)    # 0xe28a70
jmp 0x1f7638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f760a
leaq 0x679f7f(%rip), %rax    # 0x871580
movq %rax, 0xc31468(%rip)    # 0xe28a70
jmp 0x1f7636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7626
leaq 0x391743(%rip), %rax    # 0x588d60
movq %rax, 0xc3144c(%rip)    # 0xe28a70
jmp 0x1f7634
leaq 0x9fd83(%rip), %rax     # 0x2973b0
movq %rax, 0xc3143c(%rip)    # 0xe28a70
jmp 0x1f7636
jmp 0x1f7638
movq 0xc31431(%rip), %rax    # 0xe28a70
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x1f76ae
leaq 0xa8f35b(%rip), %rax    # 0xc86a00
movq %rax, 0xc313cc(%rip)    # 0xe28a78
jmp 0x1f76f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f76ca
leaq 0x68405f(%rip), %rax    # 0x87b720
movq %rax, 0xc313b0(%rip)    # 0xe28a78
jmp 0x1f76f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f76e6
leaq 0x39bae3(%rip), %rax    # 0x5931c0
movq %rax, 0xc31394(%rip)    # 0xe28a78
jmp 0x1f76f4
leaq 0x9fcc3(%rip), %rax     # 0x2973b0
movq %rax, 0xc31384(%rip)    # 0xe28a78
jmp 0x1f76f6
jmp 0x1f76f8
movq 0xc31379(%rip), %rax    # 0xe28a78
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x1f776e
leaq 0xa2cc2b(%rip), %rax    # 0xc24390
movq %rax, 0xc31314(%rip)    # 0xe28a80
jmp 0x1f77b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f778a
leaq 0x641e0f(%rip), %rax    # 0x839590
movq %rax, 0xc312f8(%rip)    # 0xe28a80
jmp 0x1f77b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f77a6
leaq 0x358cb3(%rip), %rax    # 0x550450
movq %rax, 0xc312dc(%rip)    # 0xe28a80
jmp 0x1f77b4
leaq 0x9fc03(%rip), %rax     # 0x2973b0
movq %rax, 0xc312cc(%rip)    # 0xe28a80
jmp 0x1f77b6
jmp 0x1f77b8
movq 0xc312c1(%rip), %rax    # 0xe28a80
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x1f782e
leaq 0xa3715b(%rip), %rax    # 0xc2e980
movq %rax, 0xc3125c(%rip)    # 0xe28a88
jmp 0x1f7878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f784a
leaq 0x648f8f(%rip), %rax    # 0x8407d0
movq %rax, 0xc31240(%rip)    # 0xe28a88
jmp 0x1f7876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7866
leaq 0x35fe63(%rip), %rax    # 0x5576c0
movq %rax, 0xc31224(%rip)    # 0xe28a88
jmp 0x1f7874
leaq 0x9fb43(%rip), %rax     # 0x2973b0
movq %rax, 0xc31214(%rip)    # 0xe28a88
jmp 0x1f7876
jmp 0x1f7878
movq 0xc31209(%rip), %rax    # 0xe28a88
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x1f78ee
leaq 0xa45a7b(%rip), %rax    # 0xc3d360
movq %rax, 0xc311a4(%rip)    # 0xe28a90
jmp 0x1f7938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f790a
leaq 0x65209f(%rip), %rax    # 0x8499a0
movq %rax, 0xc31188(%rip)    # 0xe28a90
jmp 0x1f7936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7926
leaq 0x369093(%rip), %rax    # 0x5609b0
movq %rax, 0xc3116c(%rip)    # 0xe28a90
jmp 0x1f7934
leaq 0x9fa83(%rip), %rax     # 0x2973b0
movq %rax, 0xc3115c(%rip)    # 0xe28a90
jmp 0x1f7936
jmp 0x1f7938
movq 0xc31151(%rip), %rax    # 0xe28a90
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_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x1f79ae
leaq 0xa5c57b(%rip), %rax    # 0xc53f20
movq %rax, 0xc310ec(%rip)    # 0xe28a98
jmp 0x1f79f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f79ca
leaq 0x65ed9f(%rip), %rax    # 0x856760
movq %rax, 0xc310d0(%rip)    # 0xe28a98
jmp 0x1f79f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f79e6
leaq 0x376423(%rip), %rax    # 0x56de00
movq %rax, 0xc310b4(%rip)    # 0xe28a98
jmp 0x1f79f4
leaq 0x9f9c3(%rip), %rax     # 0x2973b0
movq %rax, 0xc310a4(%rip)    # 0xe28a98
jmp 0x1f79f6
jmp 0x1f79f8
movq 0xc31099(%rip), %rax    # 0xe28a98
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_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7a66
leaq 0x68bb53(%rip), %rax    # 0x8835b0
movq %rax, 0xc3103c(%rip)    # 0xe28aa0
jmp 0x1f7aac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7a82
leaq 0x3a2c27(%rip), %rax    # 0x59a6a0
movq %rax, 0xc31020(%rip)    # 0xe28aa0
jmp 0x1f7aaa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7a9e
leaq 0xc8ccb(%rip), %rax     # 0x2c0760
movq %rax, 0xc31004(%rip)    # 0xe28aa0
jmp 0x1f7aa8
movq $0x0, -0x8(%rbp)
jmp 0x1f7acb
jmp 0x1f7aaa
jmp 0x1f7aac
movq 0xc30fed(%rip), %rax    # 0xe28aa0
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_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7b16
leaq 0x691f83(%rip), %rax    # 0x889a90
movq %rax, 0xc30f94(%rip)    # 0xe28aa8
jmp 0x1f7b5c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7b32
leaq 0x3a7df7(%rip), %rax    # 0x59f920
movq %rax, 0xc30f78(%rip)    # 0xe28aa8
jmp 0x1f7b5a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7b4e
leaq 0xce07b(%rip), %rax     # 0x2c5bc0
movq %rax, 0xc30f5c(%rip)    # 0xe28aa8
jmp 0x1f7b58
movq $0x0, -0x8(%rbp)
jmp 0x1f7b7b
jmp 0x1f7b5a
jmp 0x1f7b5c
movq 0xc30f45(%rip), %rax    # 0xe28aa8
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_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7bc6
leaq 0x699213(%rip), %rax    # 0x890dd0
movq %rax, 0xc30eec(%rip)    # 0xe28ab0
jmp 0x1f7c0c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7be2
leaq 0x3ad4c7(%rip), %rax    # 0x5a50a0
movq %rax, 0xc30ed0(%rip)    # 0xe28ab0
jmp 0x1f7c0a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7bfe
leaq 0xd388b(%rip), %rax     # 0x2cb480
movq %rax, 0xc30eb4(%rip)    # 0xe28ab0
jmp 0x1f7c08
movq $0x0, -0x8(%rbp)
jmp 0x1f7c2b
jmp 0x1f7c0a
jmp 0x1f7c0c
movq 0xc30e9d(%rip), %rax    # 0xe28ab0
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_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7c76
leaq 0x6a1f33(%rip), %rax    # 0x899ba0
movq %rax, 0xc30e44(%rip)    # 0xe28ab8
jmp 0x1f7cbc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7c92
leaq 0x3b3387(%rip), %rax    # 0x5ab010
movq %rax, 0xc30e28(%rip)    # 0xe28ab8
jmp 0x1f7cba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7cae
leaq 0xd9a6b(%rip), %rax     # 0x2d1710
movq %rax, 0xc30e0c(%rip)    # 0xe28ab8
jmp 0x1f7cb8
movq $0x0, -0x8(%rbp)
jmp 0x1f7cdb
jmp 0x1f7cba
jmp 0x1f7cbc
movq 0xc30df5(%rip), %rax    # 0xe28ab8
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_profile_64_pointer = parasail_sg_qx_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_profile_64_pointer = parasail_sg_qx_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_profile_64_pointer = parasail_sg_qx_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_profile_64_pointer = parasail_sg_qx_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_profile_64_pointer = parasail_sg_qx_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7d26
leaq 0x6d7083(%rip), %rax    # 0x8ceda0
movq %rax, 0xc30d9c(%rip)    # 0xe28ac0
jmp 0x1f7d6c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7d42
leaq 0x3d63a7(%rip), %rax    # 0x5ce0e0
movq %rax, 0xc30d80(%rip)    # 0xe28ac0
jmp 0x1f7d6a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7d5e
leaq 0xfd89b(%rip), %rax     # 0x2f55f0
movq %rax, 0xc30d64(%rip)    # 0xe28ac0
jmp 0x1f7d68
movq $0x0, -0x8(%rbp)
jmp 0x1f7d8b
jmp 0x1f7d6a
jmp 0x1f7d6c
movq 0xc30d4d(%rip), %rax    # 0xe28ac0
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_profile_32_pointer = parasail_sg_qx_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_profile_32_pointer = parasail_sg_qx_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_profile_32_pointer = parasail_sg_qx_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_profile_32_pointer = parasail_sg_qx_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_profile_32_pointer = parasail_sg_qx_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7dd6
leaq 0x6dc5f3(%rip), %rax    # 0x8d43c0
movq %rax, 0xc30cf4(%rip)    # 0xe28ac8
jmp 0x1f7e1c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7df2
leaq 0x3dad47(%rip), %rax    # 0x5d2b30
movq %rax, 0xc30cd8(%rip)    # 0xe28ac8
jmp 0x1f7e1a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7e0e
leaq 0x1023bb(%rip), %rax    # 0x2fa1c0
movq %rax, 0xc30cbc(%rip)    # 0xe28ac8
jmp 0x1f7e18
movq $0x0, -0x8(%rbp)
jmp 0x1f7e3b
jmp 0x1f7e1a
jmp 0x1f7e1c
movq 0xc30ca5(%rip), %rax    # 0xe28ac8
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_profile_16_pointer = parasail_sg_qx_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_profile_16_pointer = parasail_sg_qx_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_profile_16_pointer = parasail_sg_qx_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_profile_16_pointer = parasail_sg_qx_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_profile_16_pointer = parasail_sg_qx_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7e86
leaq 0x6e24c3(%rip), %rax    # 0x8da340
movq %rax, 0xc30c4c(%rip)    # 0xe28ad0
jmp 0x1f7ecc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7ea2
leaq 0x3dfae7(%rip), %rax    # 0x5d7980
movq %rax, 0xc30c30(%rip)    # 0xe28ad0
jmp 0x1f7eca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7ebe
leaq 0x10721b(%rip), %rax    # 0x2ff0d0
movq %rax, 0xc30c14(%rip)    # 0xe28ad0
jmp 0x1f7ec8
movq $0x0, -0x8(%rbp)
jmp 0x1f7eeb
jmp 0x1f7eca
jmp 0x1f7ecc
movq 0xc30bfd(%rip), %rax    # 0xe28ad0
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_qx_dispatch.c
// Function: parasail_sg_qx_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_striped_profile_8_pointer = parasail_sg_qx_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_striped_profile_8_pointer = parasail_sg_qx_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_striped_profile_8_pointer = parasail_sg_qx_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_striped_profile_8_pointer = parasail_sg_qx_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_striped_profile_8_pointer = parasail_sg_qx_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x1f7f36
leaq 0x6e9653(%rip), %rax    # 0x8e1580
movq %rax, 0xc30ba4(%rip)    # 0xe28ad8
jmp 0x1f7f7c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f7f52
leaq 0x3e50d7(%rip), %rax    # 0x5dd020
movq %rax, 0xc30b88(%rip)    # 0xe28ad8
jmp 0x1f7f7a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f7f6e
leaq 0x10cb0b(%rip), %rax    # 0x304a70
movq %rax, 0xc30b6c(%rip)    # 0xe28ad8
jmp 0x1f7f78
movq $0x0, -0x8(%rbp)
jmp 0x1f7f9b
jmp 0x1f7f7a
jmp 0x1f7f7c
movq 0xc30b55(%rip), %rax    # 0xe28ad8
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_scan_profile_64_pointer = parasail_sg_qx_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_profile_64_pointer = parasail_sg_qx_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_profile_64_pointer = parasail_sg_qx_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_profile_64_pointer = parasail_sg_qx_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_profile_64_pointer = parasail_sg_qx_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_stats_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 0x1f7fe6
leaq 0x6f47a3(%rip), %rax    # 0x8ec780
movq %rax, 0xc30afc(%rip)    # 0xe28ae0
jmp 0x1f802c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f8002
leaq 0x3ef727(%rip), %rax    # 0x5e7720
movq %rax, 0xc30ae0(%rip)    # 0xe28ae0
jmp 0x1f802a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f801e
leaq 0x11526b(%rip), %rax    # 0x30d280
movq %rax, 0xc30ac4(%rip)    # 0xe28ae0
jmp 0x1f8028
movq $0x0, -0x8(%rbp)
jmp 0x1f804b
jmp 0x1f802a
jmp 0x1f802c
movq 0xc30aad(%rip), %rax    # 0xe28ae0
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_scan_profile_32_pointer = parasail_sg_qx_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_profile_32_pointer = parasail_sg_qx_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_profile_32_pointer = parasail_sg_qx_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_profile_32_pointer = parasail_sg_qx_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_profile_32_pointer = parasail_sg_qx_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_stats_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 0x1f8096
leaq 0x7019a3(%rip), %rax    # 0x8f9a30
movq %rax, 0xc30a54(%rip)    # 0xe28ae8
jmp 0x1f80dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f80b2
leaq 0x3fa0c7(%rip), %rax    # 0x5f2170
movq %rax, 0xc30a38(%rip)    # 0xe28ae8
jmp 0x1f80da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f80ce
leaq 0x11eeab(%rip), %rax    # 0x316f70
movq %rax, 0xc30a1c(%rip)    # 0xe28ae8
jmp 0x1f80d8
movq $0x0, -0x8(%rbp)
jmp 0x1f80fb
jmp 0x1f80da
jmp 0x1f80dc
movq 0xc30a05(%rip), %rax    # 0xe28ae8
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_scan_profile_16_pointer = parasail_sg_qx_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_profile_16_pointer = parasail_sg_qx_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_profile_16_pointer = parasail_sg_qx_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_profile_16_pointer = parasail_sg_qx_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_profile_16_pointer = parasail_sg_qx_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_stats_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 0x1f8146
leaq 0x710163(%rip), %rax    # 0x9082a0
movq %rax, 0xc309ac(%rip)    # 0xe28af0
jmp 0x1f818c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f8162
leaq 0x405147(%rip), %rax    # 0x5fd2a0
movq %rax, 0xc30990(%rip)    # 0xe28af0
jmp 0x1f818a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f817e
leaq 0x12915b(%rip), %rax    # 0x3212d0
movq %rax, 0xc30974(%rip)    # 0xe28af0
jmp 0x1f8188
movq $0x0, -0x8(%rbp)
jmp 0x1f81ab
jmp 0x1f818a
jmp 0x1f818c
movq 0xc3095d(%rip), %rax    # 0xe28af0
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_scan_profile_8_pointer = parasail_sg_qx_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_scan_profile_8_pointer = parasail_sg_qx_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_scan_profile_8_pointer = parasail_sg_qx_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_scan_profile_8_pointer = parasail_sg_qx_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_scan_profile_8_pointer = parasail_sg_qx_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_stats_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 0x1f81f6
leaq 0x7210a3(%rip), %rax    # 0x919290
movq %rax, 0xc30904(%rip)    # 0xe28af8
jmp 0x1f823c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f8212
leaq 0x410c87(%rip), %rax    # 0x608e90
movq %rax, 0xc308e8(%rip)    # 0xe28af8
jmp 0x1f823a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f822e
leaq 0x1340db(%rip), %rax    # 0x32c300
movq %rax, 0xc308cc(%rip)    # 0xe28af8
jmp 0x1f8238
movq $0x0, -0x8(%rbp)
jmp 0x1f825b
jmp 0x1f823a
jmp 0x1f823c
movq 0xc308b5(%rip), %rax    # 0xe28af8
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_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_qx_stats_striped_profile_64_pointer = parasail_sg_qx_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_profile_64_pointer = parasail_sg_qx_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_profile_64_pointer = parasail_sg_qx_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_profile_64_pointer = parasail_sg_qx_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_profile_64_pointer = parasail_sg_qx_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_stats_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 0x1f82a6
leaq 0x771d23(%rip), %rax    # 0x969fc0
movq %rax, 0xc3085c(%rip)    # 0xe28b00
jmp 0x1f82ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f82c2
leaq 0x448e17(%rip), %rax    # 0x6410d0
movq %rax, 0xc30840(%rip)    # 0xe28b00
jmp 0x1f82ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f82de
leaq 0x16a4db(%rip), %rax    # 0x3627b0
movq %rax, 0xc30824(%rip)    # 0xe28b00
jmp 0x1f82e8
movq $0x0, -0x8(%rbp)
jmp 0x1f830b
jmp 0x1f82ea
jmp 0x1f82ec
movq 0xc3080d(%rip), %rax    # 0xe28b00
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)