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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_table_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_table_scan_16_pointer = parasail_sg_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_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 0x1d17ee
leaq 0x7d6d2b(%rip), %rax    # 0x9a8510
movq %rax, 0xc55f64(%rip)    # 0xe27750
jmp 0x1d1838
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d180a
leaq 0x49f68f(%rip), %rax    # 0x670e90
movq %rax, 0xc55f48(%rip)    # 0xe27750
jmp 0x1d1836
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1826
leaq 0x1c1ad3(%rip), %rax    # 0x3932f0
movq %rax, 0xc55f2c(%rip)    # 0xe27750
jmp 0x1d1834
leaq 0xc7e63(%rip), %rax     # 0x299690
movq %rax, 0xc55f1c(%rip)    # 0xe27750
jmp 0x1d1836
jmp 0x1d1838
movq 0xc55f11(%rip), %rax    # 0xe27750
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_8_dispatcher
parasail_result_t* parasail_sg_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_table_scan_8_pointer = parasail_sg_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x1d18ae
leaq 0x7e0e9b(%rip), %rax    # 0x9b2740
movq %rax, 0xc55eac(%rip)    # 0xe27758
jmp 0x1d18f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d18ca
leaq 0x4a5e9f(%rip), %rax    # 0x677760
movq %rax, 0xc55e90(%rip)    # 0xe27758
jmp 0x1d18f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d18e6
leaq 0x1c8663(%rip), %rax    # 0x399f40
movq %rax, 0xc55e74(%rip)    # 0xe27758
jmp 0x1d18f4
leaq 0xc7da3(%rip), %rax     # 0x299690
movq %rax, 0xc55e64(%rip)    # 0xe27758
jmp 0x1d18f6
jmp 0x1d18f8
movq 0xc55e59(%rip), %rax    # 0xe27758
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_striped_64_dispatcher
parasail_result_t* parasail_sg_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_table_striped_64_pointer = parasail_sg_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d196e
leaq 0x81bf5b(%rip), %rax    # 0x9ed8c0
movq %rax, 0xc55df4(%rip)    # 0xe27760
jmp 0x1d19b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d198a
leaq 0x4cbc6f(%rip), %rax    # 0x69d5f0
movq %rax, 0xc55dd8(%rip)    # 0xe27760
jmp 0x1d19b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d19a6
leaq 0x1ef443(%rip), %rax    # 0x3c0de0
movq %rax, 0xc55dbc(%rip)    # 0xe27760
jmp 0x1d19b4
leaq 0xc5d83(%rip), %rax     # 0x297730
movq %rax, 0xc55dac(%rip)    # 0xe27760
jmp 0x1d19b6
jmp 0x1d19b8
movq 0xc55da1(%rip), %rax    # 0xe27760
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_striped_32_dispatcher
parasail_result_t* parasail_sg_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_table_striped_32_pointer = parasail_sg_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d1a2e
leaq 0x821aab(%rip), %rax    # 0x9f34d0
movq %rax, 0xc55d3c(%rip)    # 0xe27768
jmp 0x1d1a78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1a4a
leaq 0x4d096f(%rip), %rax    # 0x6a23b0
movq %rax, 0xc55d20(%rip)    # 0xe27768
jmp 0x1d1a76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1a66
leaq 0x1f4383(%rip), %rax    # 0x3c5de0
movq %rax, 0xc55d04(%rip)    # 0xe27768
jmp 0x1d1a74
leaq 0xc5cc3(%rip), %rax     # 0x297730
movq %rax, 0xc55cf4(%rip)    # 0xe27768
jmp 0x1d1a76
jmp 0x1d1a78
movq 0xc55ce9(%rip), %rax    # 0xe27768
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_striped_16_dispatcher
parasail_result_t* parasail_sg_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_table_striped_16_pointer = parasail_sg_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d1aee
leaq 0x82845b(%rip), %rax    # 0x9f9f40
movq %rax, 0xc55c84(%rip)    # 0xe27770
jmp 0x1d1b38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1b0a
leaq 0x4d5c7f(%rip), %rax    # 0x6a7780
movq %rax, 0xc55c68(%rip)    # 0xe27770
jmp 0x1d1b36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1b26
leaq 0x1f97a3(%rip), %rax    # 0x3cb2c0
movq %rax, 0xc55c4c(%rip)    # 0xe27770
jmp 0x1d1b34
leaq 0xc5c03(%rip), %rax     # 0x297730
movq %rax, 0xc55c3c(%rip)    # 0xe27770
jmp 0x1d1b36
jmp 0x1d1b38
movq 0xc55c31(%rip), %rax    # 0xe27770
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_striped_8_dispatcher
parasail_result_t* parasail_sg_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_table_striped_8_pointer = parasail_sg_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d1bae
leaq 0x830b5b(%rip), %rax    # 0xa02700
movq %rax, 0xc55bcc(%rip)    # 0xe27778
jmp 0x1d1bf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1bca
leaq 0x4dbc8f(%rip), %rax    # 0x6ad850
movq %rax, 0xc55bb0(%rip)    # 0xe27778
jmp 0x1d1bf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1be6
leaq 0x1ffb23(%rip), %rax    # 0x3d1700
movq %rax, 0xc55b94(%rip)    # 0xe27778
jmp 0x1d1bf4
leaq 0xc5b43(%rip), %rax     # 0x297730
movq %rax, 0xc55b84(%rip)    # 0xe27778
jmp 0x1d1bf6
jmp 0x1d1bf8
movq 0xc55b79(%rip), %rax    # 0xe27778
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_diag_64_dispatcher
parasail_result_t* parasail_sg_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_table_diag_64_pointer = parasail_sg_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d1c6e
leaq 0x7e99bb(%rip), %rax    # 0x9bb620
movq %rax, 0xc55b14(%rip)    # 0xe27780
jmp 0x1d1cb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1c8a
leaq 0x4abd8f(%rip), %rax    # 0x67da10
movq %rax, 0xc55af8(%rip)    # 0xe27780
jmp 0x1d1cb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1ca6
leaq 0x1ce6f3(%rip), %rax    # 0x3a0390
movq %rax, 0xc55adc(%rip)    # 0xe27780
jmp 0x1d1cb4
leaq 0xc5a83(%rip), %rax     # 0x297730
movq %rax, 0xc55acc(%rip)    # 0xe27780
jmp 0x1d1cb6
jmp 0x1d1cb8
movq 0xc55ac1(%rip), %rax    # 0xe27780
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_diag_32_dispatcher
parasail_result_t* parasail_sg_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_table_diag_32_pointer = parasail_sg_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d1d2e
leaq 0x7f23db(%rip), %rax    # 0x9c4100
movq %rax, 0xc55a5c(%rip)    # 0xe27788
jmp 0x1d1d78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1d4a
leaq 0x4b1e1f(%rip), %rax    # 0x683b60
movq %rax, 0xc55a40(%rip)    # 0xe27788
jmp 0x1d1d76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1d66
leaq 0x1d4a33(%rip), %rax    # 0x3a6790
movq %rax, 0xc55a24(%rip)    # 0xe27788
jmp 0x1d1d74
leaq 0xc59c3(%rip), %rax     # 0x297730
movq %rax, 0xc55a14(%rip)    # 0xe27788
jmp 0x1d1d76
jmp 0x1d1d78
movq 0xc55a09(%rip), %rax    # 0xe27788
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_diag_16_dispatcher
parasail_result_t* parasail_sg_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_table_diag_16_pointer = parasail_sg_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d1dee
leaq 0x7fe5bb(%rip), %rax    # 0x9d03a0
movq %rax, 0xc559a4(%rip)    # 0xe27790
jmp 0x1d1e38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1e0a
leaq 0x4b983f(%rip), %rax    # 0x68b640
movq %rax, 0xc55988(%rip)    # 0xe27790
jmp 0x1d1e36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1e26
leaq 0x1dc673(%rip), %rax    # 0x3ae490
movq %rax, 0xc5596c(%rip)    # 0xe27790
jmp 0x1d1e34
leaq 0xc5903(%rip), %rax     # 0x297730
movq %rax, 0xc5595c(%rip)    # 0xe27790
jmp 0x1d1e36
jmp 0x1d1e38
movq 0xc55951(%rip), %rax    # 0xe27790
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_diag_8_dispatcher
parasail_result_t* parasail_sg_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_table_diag_8_pointer = parasail_sg_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d1eae
leaq 0x8111bb(%rip), %rax    # 0x9e3060
movq %rax, 0xc558ec(%rip)    # 0xe27798
jmp 0x1d1ef8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1eca
leaq 0x4c438f(%rip), %rax    # 0x696250
movq %rax, 0xc558d0(%rip)    # 0xe27798
jmp 0x1d1ef6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1ee6
leaq 0x1e7833(%rip), %rax    # 0x3b9710
movq %rax, 0xc558b4(%rip)    # 0xe27798
jmp 0x1d1ef4
leaq 0xc5843(%rip), %rax     # 0x297730
movq %rax, 0xc558a4(%rip)    # 0xe27798
jmp 0x1d1ef6
jmp 0x1d1ef8
movq 0xc55899(%rip), %rax    # 0xe27798
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_table_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x1d1f6e
leaq 0x83c6cb(%rip), %rax    # 0xa0e630
movq %rax, 0xc55834(%rip)    # 0xe277a0
jmp 0x1d1fb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d1f8a
leaq 0x4e69df(%rip), %rax    # 0x6b8960
movq %rax, 0xc55818(%rip)    # 0xe277a0
jmp 0x1d1fb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d1fa6
leaq 0x2086e3(%rip), %rax    # 0x3da680
movq %rax, 0xc557fc(%rip)    # 0xe277a0
jmp 0x1d1fb4
leaq 0xc76e3(%rip), %rax     # 0x299690
movq %rax, 0xc557ec(%rip)    # 0xe277a0
jmp 0x1d1fb6
jmp 0x1d1fb8
movq 0xc557e1(%rip), %rax    # 0xe277a0
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_table_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x1d202e
leaq 0x84a03b(%rip), %rax    # 0xa1c060
movq %rax, 0xc5577c(%rip)    # 0xe277a8
jmp 0x1d2078
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d204a
leaq 0x4f185f(%rip), %rax    # 0x6c38a0
movq %rax, 0xc55760(%rip)    # 0xe277a8
jmp 0x1d2076
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2066
leaq 0x2128b3(%rip), %rax    # 0x3e4910
movq %rax, 0xc55744(%rip)    # 0xe277a8
jmp 0x1d2074
leaq 0xc7623(%rip), %rax     # 0x299690
movq %rax, 0xc55734(%rip)    # 0xe277a8
jmp 0x1d2076
jmp 0x1d2078
movq 0xc55729(%rip), %rax    # 0xe277a8
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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_table_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_table_scan_16_pointer = parasail_sg_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_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 0x1d20ee
leaq 0x85946b(%rip), %rax    # 0xa2b550
movq %rax, 0xc556c4(%rip)    # 0xe277b0
jmp 0x1d2138
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d210a
leaq 0x4fcfbf(%rip), %rax    # 0x6cf0c0
movq %rax, 0xc556a8(%rip)    # 0xe277b0
jmp 0x1d2136
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2126
leaq 0x21d293(%rip), %rax    # 0x3ef3b0
movq %rax, 0xc5568c(%rip)    # 0xe277b0
jmp 0x1d2134
leaq 0xc7563(%rip), %rax     # 0x299690
movq %rax, 0xc5567c(%rip)    # 0xe277b0
jmp 0x1d2136
jmp 0x1d2138
movq 0xc55671(%rip), %rax    # 0xe277b0
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_table_scan_8_dispatcher
parasail_result_t* parasail_sg_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_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x1d21ae
leaq 0x86ba3b(%rip), %rax    # 0xa3dbe0
movq %rax, 0xc5560c(%rip)    # 0xe277b8
jmp 0x1d21f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d21ca
leaq 0x50965f(%rip), %rax    # 0x6db820
movq %rax, 0xc555f0(%rip)    # 0xe277b8
jmp 0x1d21f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d21e6
leaq 0x228dd3(%rip), %rax    # 0x3fafb0
movq %rax, 0xc555d4(%rip)    # 0xe277b8
jmp 0x1d21f4
leaq 0xc74a3(%rip), %rax     # 0x299690
movq %rax, 0xc555c4(%rip)    # 0xe277b8
jmp 0x1d21f6
jmp 0x1d21f8
movq 0xc555b9(%rip), %rax    # 0xe277b8
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_table_striped_64_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d226e
leaq 0x8c332b(%rip), %rax    # 0xa95590
movq %rax, 0xc55554(%rip)    # 0xe277c0
jmp 0x1d22b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d228a
leaq 0x5450ff(%rip), %rax    # 0x717380
movq %rax, 0xc55538(%rip)    # 0xe277c0
jmp 0x1d22b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d22a6
leaq 0x262d13(%rip), %rax    # 0x434fb0
movq %rax, 0xc5551c(%rip)    # 0xe277c0
jmp 0x1d22b4
leaq 0xc5483(%rip), %rax     # 0x297730
movq %rax, 0xc5550c(%rip)    # 0xe277c0
jmp 0x1d22b6
jmp 0x1d22b8
movq 0xc55501(%rip), %rax    # 0xe277c0
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_table_striped_32_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d232e
leaq 0x8ceb8b(%rip), %rax    # 0xaa0eb0
movq %rax, 0xc5549c(%rip)    # 0xe277c8
jmp 0x1d2378
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d234a
leaq 0x54eb4f(%rip), %rax    # 0x720e90
movq %rax, 0xc55480(%rip)    # 0xe277c8
jmp 0x1d2376
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2366
leaq 0x26c133(%rip), %rax    # 0x43e490
movq %rax, 0xc55464(%rip)    # 0xe277c8
jmp 0x1d2374
leaq 0xc53c3(%rip), %rax     # 0x297730
movq %rax, 0xc55454(%rip)    # 0xe277c8
jmp 0x1d2376
jmp 0x1d2378
movq 0xc55449(%rip), %rax    # 0xe277c8
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_table_striped_16_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d23ee
leaq 0x8db56b(%rip), %rax    # 0xaad950
movq %rax, 0xc553e4(%rip)    # 0xe277d0
jmp 0x1d2438
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d240a
leaq 0x558d7f(%rip), %rax    # 0x72b180
movq %rax, 0xc553c8(%rip)    # 0xe277d0
jmp 0x1d2436
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2426
leaq 0x275b43(%rip), %rax    # 0x447f60
movq %rax, 0xc553ac(%rip)    # 0xe277d0
jmp 0x1d2434
leaq 0xc5303(%rip), %rax     # 0x297730
movq %rax, 0xc5539c(%rip)    # 0xe277d0
jmp 0x1d2436
jmp 0x1d2438
movq 0xc55391(%rip), %rax    # 0xe277d0
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_table_striped_8_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d24ae
leaq 0x8ea2eb(%rip), %rax    # 0xabc790
movq %rax, 0xc5532c(%rip)    # 0xe277d8
jmp 0x1d24f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d24ca
leaq 0x56412f(%rip), %rax    # 0x7365f0
movq %rax, 0xc55310(%rip)    # 0xe277d8
jmp 0x1d24f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d24e6
leaq 0x280733(%rip), %rax    # 0x452c10
movq %rax, 0xc552f4(%rip)    # 0xe277d8
jmp 0x1d24f4
leaq 0xc5243(%rip), %rax     # 0x297730
movq %rax, 0xc552e4(%rip)    # 0xe277d8
jmp 0x1d24f6
jmp 0x1d24f8
movq 0xc552d9(%rip), %rax    # 0xe277d8
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_table_diag_64_dispatcher
parasail_result_t* parasail_sg_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_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d256e
leaq 0x87a99b(%rip), %rax    # 0xa4cf00
movq %rax, 0xc55274(%rip)    # 0xe277e0
jmp 0x1d25b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d258a
leaq 0x513fef(%rip), %rax    # 0x6e6570
movq %rax, 0xc55258(%rip)    # 0xe277e0
jmp 0x1d25b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d25a6
leaq 0x232ec3(%rip), %rax    # 0x405460
movq %rax, 0xc5523c(%rip)    # 0xe277e0
jmp 0x1d25b4
leaq 0xc5183(%rip), %rax     # 0x297730
movq %rax, 0xc5522c(%rip)    # 0xe277e0
jmp 0x1d25b6
jmp 0x1d25b8
movq 0xc55221(%rip), %rax    # 0xe277e0
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_table_diag_32_dispatcher
parasail_result_t* parasail_sg_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_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d262e
leaq 0x8885ab(%rip), %rax    # 0xa5abd0
movq %rax, 0xc551bc(%rip)    # 0xe277e8
jmp 0x1d2678
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d264a
leaq 0x51e09f(%rip), %rax    # 0x6f06e0
movq %rax, 0xc551a0(%rip)    # 0xe277e8
jmp 0x1d2676
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2666
leaq 0x23ca03(%rip), %rax    # 0x40f060
movq %rax, 0xc55184(%rip)    # 0xe277e8
jmp 0x1d2674
leaq 0xc50c3(%rip), %rax     # 0x297730
movq %rax, 0xc55174(%rip)    # 0xe277e8
jmp 0x1d2676
jmp 0x1d2678
movq 0xc55169(%rip), %rax    # 0xe277e8
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)