LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_16_dispatcher
parasail_result_t* parasail_sg_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_striped_16_pointer = parasail_sg_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d08ee
leaq 0x70992b(%rip), %rax    # 0x8da210
movq %rax, 0xc56dc4(%rip)    # 0xe276b0
jmp 0x1d0938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d090a
leaq 0x406f4f(%rip), %rax    # 0x5d7850
movq %rax, 0xc56da8(%rip)    # 0xe276b0
jmp 0x1d0936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0926
leaq 0x12e683(%rip), %rax    # 0x2fefa0
movq %rax, 0xc56d8c(%rip)    # 0xe276b0
jmp 0x1d0934
leaq 0xc6e03(%rip), %rax     # 0x297730
movq %rax, 0xc56d7c(%rip)    # 0xe276b0
jmp 0x1d0936
jmp 0x1d0938
movq 0xc56d71(%rip), %rax    # 0xe276b0
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_dispatch.c
// Function: parasail_sg_striped_8_dispatcher
parasail_result_t* parasail_sg_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_striped_8_pointer = parasail_sg_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d09ae
leaq 0x710aab(%rip), %rax    # 0x8e1450
movq %rax, 0xc56d0c(%rip)    # 0xe276b8
jmp 0x1d09f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d09ca
leaq 0x40c52f(%rip), %rax    # 0x5dcef0
movq %rax, 0xc56cf0(%rip)    # 0xe276b8
jmp 0x1d09f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d09e6
leaq 0x133f63(%rip), %rax    # 0x304940
movq %rax, 0xc56cd4(%rip)    # 0xe276b8
jmp 0x1d09f4
leaq 0xc6d43(%rip), %rax     # 0x297730
movq %rax, 0xc56cc4(%rip)    # 0xe276b8
jmp 0x1d09f6
jmp 0x1d09f8
movq 0xc56cb9(%rip), %rax    # 0xe276b8
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_dispatch.c
// Function: parasail_sg_diag_64_dispatcher
parasail_result_t* parasail_sg_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_diag_64_pointer = parasail_sg_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d0a6e
leaq 0x6d128b(%rip), %rax    # 0x8a1cf0
movq %rax, 0xc56c54(%rip)    # 0xe276c0
jmp 0x1d0ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0a8a
leaq 0x3e00ff(%rip), %rax    # 0x5b0b80
movq %rax, 0xc56c38(%rip)    # 0xe276c0
jmp 0x1d0ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0aa6
leaq 0x106923(%rip), %rax    # 0x2d73c0
movq %rax, 0xc56c1c(%rip)    # 0xe276c0
jmp 0x1d0ab4
leaq 0xc6c83(%rip), %rax     # 0x297730
movq %rax, 0xc56c0c(%rip)    # 0xe276c0
jmp 0x1d0ab6
jmp 0x1d0ab8
movq 0xc56c01(%rip), %rax    # 0xe276c0
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_dispatch.c
// Function: parasail_sg_diag_32_dispatcher
parasail_result_t* parasail_sg_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_diag_32_pointer = parasail_sg_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d0b2e
leaq 0x6d933b(%rip), %rax    # 0x8a9e60
movq %rax, 0xc56b9c(%rip)    # 0xe276c8
jmp 0x1d0b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0b4a
leaq 0x3e5cbf(%rip), %rax    # 0x5b6800
movq %rax, 0xc56b80(%rip)    # 0xe276c8
jmp 0x1d0b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0b66
leaq 0x10c703(%rip), %rax    # 0x2dd260
movq %rax, 0xc56b64(%rip)    # 0xe276c8
jmp 0x1d0b74
leaq 0xc6bc3(%rip), %rax     # 0x297730
movq %rax, 0xc56b54(%rip)    # 0xe276c8
jmp 0x1d0b76
jmp 0x1d0b78
movq 0xc56b49(%rip), %rax    # 0xe276c8
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_dispatch.c
// Function: parasail_sg_diag_16_dispatcher
parasail_result_t* parasail_sg_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_diag_16_pointer = parasail_sg_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d0bee
leaq 0x6e422b(%rip), %rax    # 0x8b4e10
movq %rax, 0xc56ae4(%rip)    # 0xe276d0
jmp 0x1d0c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0c0a
leaq 0x3ecdef(%rip), %rax    # 0x5bd9f0
movq %rax, 0xc56ac8(%rip)    # 0xe276d0
jmp 0x1d0c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0c26
leaq 0x113a13(%rip), %rax    # 0x2e4630
movq %rax, 0xc56aac(%rip)    # 0xe276d0
jmp 0x1d0c34
leaq 0xc6b03(%rip), %rax     # 0x297730
movq %rax, 0xc56a9c(%rip)    # 0xe276d0
jmp 0x1d0c36
jmp 0x1d0c38
movq 0xc56a91(%rip), %rax    # 0xe276d0
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_dispatch.c
// Function: parasail_sg_diag_8_dispatcher
parasail_result_t* parasail_sg_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_diag_8_pointer = parasail_sg_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d0cae
leaq 0x6f491b(%rip), %rax    # 0x8c55c0
movq %rax, 0xc56a2c(%rip)    # 0xe276d8
jmp 0x1d0cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0cca
leaq 0x3f680f(%rip), %rax    # 0x5c74d0
movq %rax, 0xc56a10(%rip)    # 0xe276d8
jmp 0x1d0cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0ce6
leaq 0x11da43(%rip), %rax    # 0x2ee720
movq %rax, 0xc569f4(%rip)    # 0xe276d8
jmp 0x1d0cf4
leaq 0xc6a43(%rip), %rax     # 0x297730
movq %rax, 0xc569e4(%rip)    # 0xe276d8
jmp 0x1d0cf6
jmp 0x1d0cf8
movq 0xc569d9(%rip), %rax    # 0xe276d8
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_dispatch.c
// Function: parasail_sg_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d0d6e
leaq 0x71b8eb(%rip), %rax    # 0x8ec650
movq %rax, 0xc56974(%rip)    # 0xe276e0
jmp 0x1d0db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0d8a
leaq 0x41686f(%rip), %rax    # 0x5e75f0
movq %rax, 0xc56958(%rip)    # 0xe276e0
jmp 0x1d0db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0da6
leaq 0x13c3b3(%rip), %rax    # 0x30d150
movq %rax, 0xc5693c(%rip)    # 0xe276e0
jmp 0x1d0db4
leaq 0xc88e3(%rip), %rax     # 0x299690
movq %rax, 0xc5692c(%rip)    # 0xe276e0
jmp 0x1d0db6
jmp 0x1d0db8
movq 0xc56921(%rip), %rax    # 0xe276e0
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_dispatch.c
// Function: parasail_sg_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d0e2e
leaq 0x728adb(%rip), %rax    # 0x8f9900
movq %rax, 0xc568bc(%rip)    # 0xe276e8
jmp 0x1d0e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0e4a
leaq 0x4211ff(%rip), %rax    # 0x5f2040
movq %rax, 0xc568a0(%rip)    # 0xe276e8
jmp 0x1d0e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0e66
leaq 0x145fe3(%rip), %rax    # 0x316e40
movq %rax, 0xc56884(%rip)    # 0xe276e8
jmp 0x1d0e74
leaq 0xc8823(%rip), %rax     # 0x299690
movq %rax, 0xc56874(%rip)    # 0xe276e8
jmp 0x1d0e76
jmp 0x1d0e78
movq 0xc56869(%rip), %rax    # 0xe276e8
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_dispatch.c
// Function: parasail_sg_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d0eee
leaq 0x73728b(%rip), %rax    # 0x908170
movq %rax, 0xc56804(%rip)    # 0xe276f0
jmp 0x1d0f38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0f0a
leaq 0x42c26f(%rip), %rax    # 0x5fd170
movq %rax, 0xc567e8(%rip)    # 0xe276f0
jmp 0x1d0f36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0f26
leaq 0x150283(%rip), %rax    # 0x3211a0
movq %rax, 0xc567cc(%rip)    # 0xe276f0
jmp 0x1d0f34
leaq 0xc8763(%rip), %rax     # 0x299690
movq %rax, 0xc567bc(%rip)    # 0xe276f0
jmp 0x1d0f36
jmp 0x1d0f38
movq 0xc567b1(%rip), %rax    # 0xe276f0
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_dispatch.c
// Function: parasail_sg_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d0fae
leaq 0x7481bb(%rip), %rax    # 0x919160
movq %rax, 0xc5674c(%rip)    # 0xe276f8
jmp 0x1d0ff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d0fca
leaq 0x437d9f(%rip), %rax    # 0x608d60
movq %rax, 0xc56730(%rip)    # 0xe276f8
jmp 0x1d0ff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d0fe6
leaq 0x15b1f3(%rip), %rax    # 0x32c1d0
movq %rax, 0xc56714(%rip)    # 0xe276f8
jmp 0x1d0ff4
leaq 0xc86a3(%rip), %rax     # 0x299690
movq %rax, 0xc56704(%rip)    # 0xe276f8
jmp 0x1d0ff6
jmp 0x1d0ff8
movq 0xc566f9(%rip), %rax    # 0xe276f8
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_dispatch.c
// Function: parasail_sg_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d106e
leaq 0x798e2b(%rip), %rax    # 0x969e90
movq %rax, 0xc56694(%rip)    # 0xe27700
jmp 0x1d10b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d108a
leaq 0x46ff1f(%rip), %rax    # 0x640fa0
movq %rax, 0xc56678(%rip)    # 0xe27700
jmp 0x1d10b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d10a6
leaq 0x1915e3(%rip), %rax    # 0x362680
movq %rax, 0xc5665c(%rip)    # 0xe27700
jmp 0x1d10b4
leaq 0xc6683(%rip), %rax     # 0x297730
movq %rax, 0xc5664c(%rip)    # 0xe27700
jmp 0x1d10b6
jmp 0x1d10b8
movq 0xc56641(%rip), %rax    # 0xe27700
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_dispatch.c
// Function: parasail_sg_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d112e
leaq 0x7a3d2b(%rip), %rax    # 0x974e50
movq %rax, 0xc565dc(%rip)    # 0xe27708
jmp 0x1d1178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d114a
leaq 0x4792ff(%rip), %rax    # 0x64a440
movq %rax, 0xc565c0(%rip)    # 0xe27708
jmp 0x1d1176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1166
leaq 0x19a2c3(%rip), %rax    # 0x36b420
movq %rax, 0xc565a4(%rip)    # 0xe27708
jmp 0x1d1174
leaq 0xc65c3(%rip), %rax     # 0x297730
movq %rax, 0xc56594(%rip)    # 0xe27708
jmp 0x1d1176
jmp 0x1d1178
movq 0xc56589(%rip), %rax    # 0xe27708
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_dispatch.c
// Function: parasail_sg_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d11ee
leaq 0x7af8ab(%rip), %rax    # 0x980a90
movq %rax, 0xc56524(%rip)    # 0xe27710
jmp 0x1d1238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d120a
leaq 0x482caf(%rip), %rax    # 0x653eb0
movq %rax, 0xc56508(%rip)    # 0xe27710
jmp 0x1d1236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1226
leaq 0x1a3403(%rip), %rax    # 0x374620
movq %rax, 0xc564ec(%rip)    # 0xe27710
jmp 0x1d1234
leaq 0xc6503(%rip), %rax     # 0x297730
movq %rax, 0xc564dc(%rip)    # 0xe27710
jmp 0x1d1236
jmp 0x1d1238
movq 0xc564d1(%rip), %rax    # 0xe27710
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_dispatch.c
// Function: parasail_sg_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d12ae
leaq 0x7bccfb(%rip), %rax    # 0x98dfa0
movq %rax, 0xc5646c(%rip)    # 0xe27718
jmp 0x1d12f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d12ca
leaq 0x48d2ff(%rip), %rax    # 0x65e5c0
movq %rax, 0xc56450(%rip)    # 0xe27718
jmp 0x1d12f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d12e6
leaq 0x1ad223(%rip), %rax    # 0x37e500
movq %rax, 0xc56434(%rip)    # 0xe27718
jmp 0x1d12f4
leaq 0xc6443(%rip), %rax     # 0x297730
movq %rax, 0xc56424(%rip)    # 0xe27718
jmp 0x1d12f6
jmp 0x1d12f8
movq 0xc56419(%rip), %rax    # 0xe27718
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_dispatch.c
// Function: parasail_sg_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d136e
leaq 0x75625b(%rip), %rax    # 0x9275c0
movq %rax, 0xc563b4(%rip)    # 0xe27720
jmp 0x1d13b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d138a
leaq 0x441f1f(%rip), %rax    # 0x6132a0
movq %rax, 0xc56398(%rip)    # 0xe27720
jmp 0x1d13b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d13a6
leaq 0x164a73(%rip), %rax    # 0x335e10
movq %rax, 0xc5637c(%rip)    # 0xe27720
jmp 0x1d13b4
leaq 0xc6383(%rip), %rax     # 0x297730
movq %rax, 0xc5636c(%rip)    # 0xe27720
jmp 0x1d13b6
jmp 0x1d13b8
movq 0xc56361(%rip), %rax    # 0xe27720
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_dispatch.c
// Function: parasail_sg_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d142e
leaq 0x76329b(%rip), %rax    # 0x9346c0
movq %rax, 0xc562fc(%rip)    # 0xe27728
jmp 0x1d1478
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d144a
leaq 0x44b8ff(%rip), %rax    # 0x61cd40
movq %rax, 0xc562e0(%rip)    # 0xe27728
jmp 0x1d1476
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1466
leaq 0x16de53(%rip), %rax    # 0x33f2b0
movq %rax, 0xc562c4(%rip)    # 0xe27728
jmp 0x1d1474
leaq 0xc62c3(%rip), %rax     # 0x297730
movq %rax, 0xc562b4(%rip)    # 0xe27728
jmp 0x1d1476
jmp 0x1d1478
movq 0xc562a9(%rip), %rax    # 0xe27728
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_dispatch.c
// Function: parasail_sg_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d14ee
leaq 0x7735bb(%rip), %rax    # 0x944aa0
movq %rax, 0xc56244(%rip)    # 0xe27730
jmp 0x1d1538
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d150a
leaq 0x456a9f(%rip), %rax    # 0x627fa0
movq %rax, 0xc56228(%rip)    # 0xe27730
jmp 0x1d1536
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1526
leaq 0x178943(%rip), %rax    # 0x349e60
movq %rax, 0xc5620c(%rip)    # 0xe27730
jmp 0x1d1534
leaq 0xc6203(%rip), %rax     # 0x297730
movq %rax, 0xc561fc(%rip)    # 0xe27730
jmp 0x1d1536
jmp 0x1d1538
movq 0xc561f1(%rip), %rax    # 0xe27730
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_dispatch.c
// Function: parasail_sg_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x1d15ae
leaq 0x78989b(%rip), %rax    # 0x95ae40
movq %rax, 0xc5618c(%rip)    # 0xe27738
jmp 0x1d15f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d15ca
leaq 0x4647cf(%rip), %rax    # 0x635d90
movq %rax, 0xc56170(%rip)    # 0xe27738
jmp 0x1d15f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d15e6
leaq 0x186473(%rip), %rax    # 0x357a50
movq %rax, 0xc56154(%rip)    # 0xe27738
jmp 0x1d15f4
leaq 0xc6143(%rip), %rax     # 0x297730
movq %rax, 0xc56144(%rip)    # 0xe27738
jmp 0x1d15f6
jmp 0x1d15f8
movq 0xc56139(%rip), %rax    # 0xe27738
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_dispatch.c
// Function: parasail_sg_table_scan_64_dispatcher
parasail_result_t* parasail_sg_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_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 0x1d166e
leaq 0x7c870b(%rip), %rax    # 0x999d70
movq %rax, 0xc560d4(%rip)    # 0xe27740
jmp 0x1d16b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d168a
leaq 0x49464f(%rip), %rax    # 0x665cd0
movq %rax, 0xc560b8(%rip)    # 0xe27740
jmp 0x1d16b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d16a6
leaq 0x1b6663(%rip), %rax    # 0x387d00
movq %rax, 0xc5609c(%rip)    # 0xe27740
jmp 0x1d16b4
leaq 0xc7fe3(%rip), %rax     # 0x299690
movq %rax, 0xc5608c(%rip)    # 0xe27740
jmp 0x1d16b6
jmp 0x1d16b8
movq 0xc56081(%rip), %rax    # 0xe27740
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_dispatch.c
// Function: parasail_sg_table_scan_32_dispatcher
parasail_result_t* parasail_sg_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_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 0x1d172e
leaq 0x7cf06b(%rip), %rax    # 0x9a0790
movq %rax, 0xc5601c(%rip)    # 0xe27748
jmp 0x1d1778
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d174a
leaq 0x499adf(%rip), %rax    # 0x66b220
movq %rax, 0xc56000(%rip)    # 0xe27748
jmp 0x1d1776
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1766
leaq 0x1bbd93(%rip), %rax    # 0x38d4f0
movq %rax, 0xc55fe4(%rip)    # 0xe27748
jmp 0x1d1774
leaq 0xc7f23(%rip), %rax     # 0x299690
movq %rax, 0xc55fd4(%rip)    # 0xe27748
jmp 0x1d1776
jmp 0x1d1778
movq 0xc55fc9(%rip), %rax    # 0xe27748
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)