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_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f58ae
leaq 0x847fbb(%rip), %rax    # 0xa3d860
movq %rax, 0xc3308c(%rip)    # 0xe28938
jmp 0x1f58f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f58ca
leaq 0x4e5bdf(%rip), %rax    # 0x6db4a0
movq %rax, 0xc33070(%rip)    # 0xe28938
jmp 0x1f58f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f58e6
leaq 0x205353(%rip), %rax    # 0x3fac30
movq %rax, 0xc33054(%rip)    # 0xe28938
jmp 0x1f58f4
leaq 0xa3a23(%rip), %rax     # 0x299310
movq %rax, 0xc33044(%rip)    # 0xe28938
jmp 0x1f58f6
jmp 0x1f58f8
movq 0xc33039(%rip), %rax    # 0xe28938
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_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f596e
leaq 0x89f8ab(%rip), %rax    # 0xa95210
movq %rax, 0xc32fd4(%rip)    # 0xe28940
jmp 0x1f59b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f598a
leaq 0x52167f(%rip), %rax    # 0x717000
movq %rax, 0xc32fb8(%rip)    # 0xe28940
jmp 0x1f59b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f59a6
leaq 0x23f293(%rip), %rax    # 0x434c30
movq %rax, 0xc32f9c(%rip)    # 0xe28940
jmp 0x1f59b4
leaq 0xa1a03(%rip), %rax     # 0x2973b0
movq %rax, 0xc32f8c(%rip)    # 0xe28940
jmp 0x1f59b6
jmp 0x1f59b8
movq 0xc32f81(%rip), %rax    # 0xe28940
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_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_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 0x1f5a2e
leaq 0x8ab10b(%rip), %rax    # 0xaa0b30
movq %rax, 0xc32f1c(%rip)    # 0xe28948
jmp 0x1f5a78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5a4a
leaq 0x52b0cf(%rip), %rax    # 0x720b10
movq %rax, 0xc32f00(%rip)    # 0xe28948
jmp 0x1f5a76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5a66
leaq 0x2486b3(%rip), %rax    # 0x43e110
movq %rax, 0xc32ee4(%rip)    # 0xe28948
jmp 0x1f5a74
leaq 0xa1943(%rip), %rax     # 0x2973b0
movq %rax, 0xc32ed4(%rip)    # 0xe28948
jmp 0x1f5a76
jmp 0x1f5a78
movq 0xc32ec9(%rip), %rax    # 0xe28948
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_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_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 0x1f5aee
leaq 0x8b7aeb(%rip), %rax    # 0xaad5d0
movq %rax, 0xc32e64(%rip)    # 0xe28950
jmp 0x1f5b38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5b0a
leaq 0x5352ff(%rip), %rax    # 0x72ae00
movq %rax, 0xc32e48(%rip)    # 0xe28950
jmp 0x1f5b36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5b26
leaq 0x2520c3(%rip), %rax    # 0x447be0
movq %rax, 0xc32e2c(%rip)    # 0xe28950
jmp 0x1f5b34
leaq 0xa1883(%rip), %rax     # 0x2973b0
movq %rax, 0xc32e1c(%rip)    # 0xe28950
jmp 0x1f5b36
jmp 0x1f5b38
movq 0xc32e11(%rip), %rax    # 0xe28950
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_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_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 0x1f5bae
leaq 0x8c686b(%rip), %rax    # 0xabc410
movq %rax, 0xc32dac(%rip)    # 0xe28958
jmp 0x1f5bf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5bca
leaq 0x5406af(%rip), %rax    # 0x736270
movq %rax, 0xc32d90(%rip)    # 0xe28958
jmp 0x1f5bf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5be6
leaq 0x25ccb3(%rip), %rax    # 0x452890
movq %rax, 0xc32d74(%rip)    # 0xe28958
jmp 0x1f5bf4
leaq 0xa17c3(%rip), %rax     # 0x2973b0
movq %rax, 0xc32d64(%rip)    # 0xe28958
jmp 0x1f5bf6
jmp 0x1f5bf8
movq 0xc32d59(%rip), %rax    # 0xe28958
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_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_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 0x1f5c6e
leaq 0x856f1b(%rip), %rax    # 0xa4cb80
movq %rax, 0xc32cf4(%rip)    # 0xe28960
jmp 0x1f5cb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5c8a
leaq 0x4f056f(%rip), %rax    # 0x6e61f0
movq %rax, 0xc32cd8(%rip)    # 0xe28960
jmp 0x1f5cb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5ca6
leaq 0x20f443(%rip), %rax    # 0x4050e0
movq %rax, 0xc32cbc(%rip)    # 0xe28960
jmp 0x1f5cb4
leaq 0xa1703(%rip), %rax     # 0x2973b0
movq %rax, 0xc32cac(%rip)    # 0xe28960
jmp 0x1f5cb6
jmp 0x1f5cb8
movq 0xc32ca1(%rip), %rax    # 0xe28960
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_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_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 0x1f5d2e
leaq 0x864b2b(%rip), %rax    # 0xa5a850
movq %rax, 0xc32c3c(%rip)    # 0xe28968
jmp 0x1f5d78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5d4a
leaq 0x4fa61f(%rip), %rax    # 0x6f0360
movq %rax, 0xc32c20(%rip)    # 0xe28968
jmp 0x1f5d76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5d66
leaq 0x218f83(%rip), %rax    # 0x40ece0
movq %rax, 0xc32c04(%rip)    # 0xe28968
jmp 0x1f5d74
leaq 0xa1643(%rip), %rax     # 0x2973b0
movq %rax, 0xc32bf4(%rip)    # 0xe28968
jmp 0x1f5d76
jmp 0x1f5d78
movq 0xc32be9(%rip), %rax    # 0xe28968
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_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_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 0x1f5dee
leaq 0x87637b(%rip), %rax    # 0xa6c160
movq %rax, 0xc32b84(%rip)    # 0xe28970
jmp 0x1f5e38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5e0a
leaq 0x5062af(%rip), %rax    # 0x6fc0b0
movq %rax, 0xc32b68(%rip)    # 0xe28970
jmp 0x1f5e36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5e26
leaq 0x2245b3(%rip), %rax    # 0x41a3d0
movq %rax, 0xc32b4c(%rip)    # 0xe28970
jmp 0x1f5e34
leaq 0xa1583(%rip), %rax     # 0x2973b0
movq %rax, 0xc32b3c(%rip)    # 0xe28970
jmp 0x1f5e36
jmp 0x1f5e38
movq 0xc32b31(%rip), %rax    # 0xe28970
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_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_table_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 0x1f5eae
leaq 0x88edab(%rip), %rax    # 0xa84c50
movq %rax, 0xc32acc(%rip)    # 0xe28978
jmp 0x1f5ef8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5eca
leaq 0x51530f(%rip), %rax    # 0x70b1d0
movq %rax, 0xc32ab0(%rip)    # 0xe28978
jmp 0x1f5ef6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5ee6
leaq 0x233483(%rip), %rax    # 0x429360
movq %rax, 0xc32a94(%rip)    # 0xe28978
jmp 0x1f5ef4
leaq 0xa14c3(%rip), %rax     # 0x2973b0
movq %rax, 0xc32a84(%rip)    # 0xe28978
jmp 0x1f5ef6
jmp 0x1f5ef8
movq 0xc32a79(%rip), %rax    # 0xe28978
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_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f5f6e
leaq 0x8d036b(%rip), %rax    # 0xac62d0
movq %rax, 0xc32a14(%rip)    # 0xe28980
jmp 0x1f5fb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f5f8a
leaq 0x547fcf(%rip), %rax    # 0x73df50
movq %rax, 0xc329f8(%rip)    # 0xe28980
jmp 0x1f5fb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5fa6
leaq 0x2642a3(%rip), %rax    # 0x45a240
movq %rax, 0xc329dc(%rip)    # 0xe28980
jmp 0x1f5fb4
leaq 0xa3363(%rip), %rax     # 0x299310
movq %rax, 0xc329cc(%rip)    # 0xe28980
jmp 0x1f5fb6
jmp 0x1f5fb8
movq 0xc329c1(%rip), %rax    # 0xe28980
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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f602e
leaq 0x8d6e7b(%rip), %rax    # 0xaccea0
movq %rax, 0xc3295c(%rip)    # 0xe28988
jmp 0x1f6078
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f604a
leaq 0x54d65f(%rip), %rax    # 0x7436a0
movq %rax, 0xc32940(%rip)    # 0xe28988
jmp 0x1f6076
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f6066
leaq 0x269bd3(%rip), %rax    # 0x45fc30
movq %rax, 0xc32924(%rip)    # 0xe28988
jmp 0x1f6074
leaq 0xa32a3(%rip), %rax     # 0x299310
movq %rax, 0xc32914(%rip)    # 0xe28988
jmp 0x1f6076
jmp 0x1f6078
movq 0xc32909(%rip), %rax    # 0xe28988
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_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f60ee
leaq 0x8debab(%rip), %rax    # 0xad4c90
movq %rax, 0xc328a4(%rip)    # 0xe28990
jmp 0x1f6138
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f610a
leaq 0x55338f(%rip), %rax    # 0x749490
movq %rax, 0xc32888(%rip)    # 0xe28990
jmp 0x1f6136
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f6126
leaq 0x26fa83(%rip), %rax    # 0x465ba0
movq %rax, 0xc3286c(%rip)    # 0xe28990
jmp 0x1f6134
leaq 0xa31e3(%rip), %rax     # 0x299310
movq %rax, 0xc3285c(%rip)    # 0xe28990
jmp 0x1f6136
jmp 0x1f6138
movq 0xc32851(%rip), %rax    # 0xe28990
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_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f61ae
leaq 0x8e8adb(%rip), %rax    # 0xadec80
movq %rax, 0xc327ec(%rip)    # 0xe28998
jmp 0x1f61f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f61ca
leaq 0x559bef(%rip), %rax    # 0x74fdb0
movq %rax, 0xc327d0(%rip)    # 0xe28998
jmp 0x1f61f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f61e6
leaq 0x276603(%rip), %rax    # 0x46c7e0
movq %rax, 0xc327b4(%rip)    # 0xe28998
jmp 0x1f61f4
leaq 0xa3123(%rip), %rax     # 0x299310
movq %rax, 0xc327a4(%rip)    # 0xe28998
jmp 0x1f61f6
jmp 0x1f61f8
movq 0xc32799(%rip), %rax    # 0xe28998
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_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f626e
leaq 0x925a3b(%rip), %rax    # 0xb1bca0
movq %rax, 0xc32734(%rip)    # 0xe289a0
jmp 0x1f62b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f628a
leaq 0x58087f(%rip), %rax    # 0x776b00
movq %rax, 0xc32718(%rip)    # 0xe289a0
jmp 0x1f62b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f62a6
leaq 0x29e3d3(%rip), %rax    # 0x494670
movq %rax, 0xc326fc(%rip)    # 0xe289a0
jmp 0x1f62b4
leaq 0xa1103(%rip), %rax     # 0x2973b0
movq %rax, 0xc326ec(%rip)    # 0xe289a0
jmp 0x1f62b6
jmp 0x1f62b8
movq 0xc326e1(%rip), %rax    # 0xe289a0
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_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_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 0x1f632e
leaq 0x92b69b(%rip), %rax    # 0xb219c0
movq %rax, 0xc3267c(%rip)    # 0xe289a8
jmp 0x1f6378
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f634a
leaq 0x5856df(%rip), %rax    # 0x77ba20
movq %rax, 0xc32660(%rip)    # 0xe289a8
jmp 0x1f6376
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f6366
leaq 0x2a3473(%rip), %rax    # 0x4997d0
movq %rax, 0xc32644(%rip)    # 0xe289a8
jmp 0x1f6374
leaq 0xa1043(%rip), %rax     # 0x2973b0
movq %rax, 0xc32634(%rip)    # 0xe289a8
jmp 0x1f6376
jmp 0x1f6378
movq 0xc32629(%rip), %rax    # 0xe289a8
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_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_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 0x1f63ee
leaq 0x93200b(%rip), %rax    # 0xb283f0
movq %rax, 0xc325c4(%rip)    # 0xe289b0
jmp 0x1f6438
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f640a
leaq 0x58aacf(%rip), %rax    # 0x780ed0
movq %rax, 0xc325a8(%rip)    # 0xe289b0
jmp 0x1f6436
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f6426
leaq 0x2a8973(%rip), %rax    # 0x49ed90
movq %rax, 0xc3258c(%rip)    # 0xe289b0
jmp 0x1f6434
leaq 0xa0f83(%rip), %rax     # 0x2973b0
movq %rax, 0xc3257c(%rip)    # 0xe289b0
jmp 0x1f6436
jmp 0x1f6438
movq 0xc32571(%rip), %rax    # 0xe289b0
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_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_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 0x1f64ae
leaq 0x93a43b(%rip), %rax    # 0xb308e0
movq %rax, 0xc3250c(%rip)    # 0xe289b8
jmp 0x1f64f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f64ca
leaq 0x590a6f(%rip), %rax    # 0x786f30
movq %rax, 0xc324f0(%rip)    # 0xe289b8
jmp 0x1f64f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f64e6
leaq 0x2aec23(%rip), %rax    # 0x4a5100
movq %rax, 0xc324d4(%rip)    # 0xe289b8
jmp 0x1f64f4
leaq 0xa0ec3(%rip), %rax     # 0x2973b0
movq %rax, 0xc324c4(%rip)    # 0xe289b8
jmp 0x1f64f6
jmp 0x1f64f8
movq 0xc324b9(%rip), %rax    # 0xe289b8
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_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_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 0x1f656e
leaq 0x8f165b(%rip), %rax    # 0xae7bc0
movq %rax, 0xc32454(%rip)    # 0xe289c0
jmp 0x1f65b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f658a
leaq 0x55fbaf(%rip), %rax    # 0x756130
movq %rax, 0xc32438(%rip)    # 0xe289c0
jmp 0x1f65b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f65a6
leaq 0x27c773(%rip), %rax    # 0x472d10
movq %rax, 0xc3241c(%rip)    # 0xe289c0
jmp 0x1f65b4
leaq 0xa0e03(%rip), %rax     # 0x2973b0
movq %rax, 0xc3240c(%rip)    # 0xe289c0
jmp 0x1f65b6
jmp 0x1f65b8
movq 0xc32401(%rip), %rax    # 0xe289c0
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_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_rowcol_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_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_rowcol_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_rowcol_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 0x1f662e
leaq 0x8fa34b(%rip), %rax    # 0xaf0970
movq %rax, 0xc3239c(%rip)    # 0xe289c8
jmp 0x1f6678
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f664a
leaq 0x565d8f(%rip), %rax    # 0x75c3d0
movq %rax, 0xc32380(%rip)    # 0xe289c8
jmp 0x1f6676
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f6666
leaq 0x282c83(%rip), %rax    # 0x4792e0
movq %rax, 0xc32364(%rip)    # 0xe289c8
jmp 0x1f6674
leaq 0xa0d43(%rip), %rax     # 0x2973b0
movq %rax, 0xc32354(%rip)    # 0xe289c8
jmp 0x1f6676
jmp 0x1f6678
movq 0xc32349(%rip), %rax    # 0xe289c8
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)