LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211520
leaq 0x314f21(%rip), %rax    # 0x52643f
jmp 0x21154f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211534
leaq 0x218935(%rip), %rax    # 0x429e67
jmp 0x21154f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211548
leaq 0x8950c(%rip), %rax     # 0x29aa52
jmp 0x21154f
leaq 0x12e467(%rip), %rax    # 0x33f9b6
movq %rax, 0x5912c2(%rip)    # 0x7a2818
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2115a9
leaq 0x3273d9(%rip), %rax    # 0x538980
jmp 0x2115d8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2115bd
leaq 0x224d68(%rip), %rax    # 0x436323
jmp 0x2115d8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2115d1
leaq 0x88605(%rip), %rax     # 0x299bd4
jmp 0x2115d8
leaq 0x13b6f8(%rip), %rax    # 0x34ccd0
movq %rax, 0x591241(%rip)    # 0x7a2820
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211632
leaq 0x328e55(%rip), %rax    # 0x53a485
jmp 0x211661
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211646
leaq 0x226593(%rip), %rax    # 0x437bd7
jmp 0x211661
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21165a
leaq 0x8857c(%rip), %rax     # 0x299bd4
jmp 0x211661
leaq 0x13d088(%rip), %rax    # 0x34e6e9
movq %rax, 0x5911c0(%rip)    # 0x7a2828
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2116bb
leaq 0x32a869(%rip), %rax    # 0x53bf22
jmp 0x2116ea
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2116cf
leaq 0x227cef(%rip), %rax    # 0x4393bc
jmp 0x2116ea
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2116e3
leaq 0x884f3(%rip), %rax     # 0x299bd4
jmp 0x2116ea
leaq 0x13e8aa(%rip), %rax    # 0x34ff94
movq %rax, 0x59113f(%rip)    # 0x7a2830
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211744
leaq 0x32c8c0(%rip), %rax    # 0x53e002
jmp 0x211773
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211758
leaq 0x229745(%rip), %rax    # 0x43ae9b
jmp 0x211773
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21176c
leaq 0x8846a(%rip), %rax     # 0x299bd4
jmp 0x211773
leaq 0x140539(%rip), %rax    # 0x351cac
movq %rax, 0x5910be(%rip)    # 0x7a2838
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2117cd
leaq 0x31755a(%rip), %rax    # 0x528d25
jmp 0x2117fc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2117e1
leaq 0x21a63c(%rip), %rax    # 0x42be1b
jmp 0x2117fc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2117f5
leaq 0x883e1(%rip), %rax     # 0x299bd4
jmp 0x2117fc
leaq 0x130492(%rip), %rax    # 0x341c8e
movq %rax, 0x59103d(%rip)    # 0x7a2840
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211856
leaq 0x319d54(%rip), %rax    # 0x52b5a8
jmp 0x211885
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21186a
leaq 0x21c384(%rip), %rax    # 0x42dbec
jmp 0x211885
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21187e
leaq 0x88358(%rip), %rax     # 0x299bd4
jmp 0x211885
leaq 0x13258c(%rip), %rax    # 0x343e11
movq %rax, 0x590fbc(%rip)    # 0x7a2848
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_rowcol_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_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2118df
leaq 0x31d530(%rip), %rax    # 0x52ee0d
jmp 0x21190e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2118f3
leaq 0x21e85b(%rip), %rax    # 0x43014c
jmp 0x21190e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211907
leaq 0x882cf(%rip), %rax     # 0x299bd4
jmp 0x21190e
leaq 0x134c8c(%rip), %rax    # 0x34659a
movq %rax, 0x590f3b(%rip)    # 0x7a2850
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_rowcol_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_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211968
leaq 0x3232e7(%rip), %rax    # 0x534c4d
jmp 0x211997
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21197c
leaq 0x2220b6(%rip), %rax    # 0x433a30
jmp 0x211997
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211990
leaq 0x88246(%rip), %rax     # 0x299bd4
jmp 0x211997
leaq 0x1387b6(%rip), %rax    # 0x34a14d
movq %rax, 0x590eba(%rip)    # 0x7a2858
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2119f1
leaq 0x33025c(%rip), %rax    # 0x541c4b
jmp 0x211a20
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211a05
leaq 0x22cd99(%rip), %rax    # 0x43e79c
jmp 0x211a20
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211a19
leaq 0x8903b(%rip), %rax     # 0x29aa52
jmp 0x211a20
leaq 0x1438aa(%rip), %rax    # 0x3552ca
movq %rax, 0x590e39(%rip)    # 0x7a2860
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211a7a
leaq 0x333e6a(%rip), %rax    # 0x5458e2
jmp 0x211aa9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211a8e
leaq 0x230382(%rip), %rax    # 0x441e0e
jmp 0x211aa9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211aa2
leaq 0x88fb2(%rip), %rax     # 0x29aa52
jmp 0x211aa9
leaq 0x147536(%rip), %rax    # 0x358fdf
movq %rax, 0x590db8(%rip)    # 0x7a2868
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211b03
leaq 0x337e8b(%rip), %rax    # 0x54998c
jmp 0x211b32
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211b17
leaq 0x233b04(%rip), %rax    # 0x445619
jmp 0x211b32
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211b2b
leaq 0x88f29(%rip), %rax     # 0x29aa52
jmp 0x211b32
leaq 0x14b132(%rip), %rax    # 0x35cc64
movq %rax, 0x590d37(%rip)    # 0x7a2870
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211b8c
leaq 0x33befd(%rip), %rax    # 0x54da87
jmp 0x211bbb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211ba0
leaq 0x237b52(%rip), %rax    # 0x4496f0
jmp 0x211bbb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211bb4
leaq 0x88ea0(%rip), %rax     # 0x29aa52
jmp 0x211bbb
leaq 0x14f733(%rip), %rax    # 0x3612ee
movq %rax, 0x590cb6(%rip)    # 0x7a2878
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211c15
leaq 0x3567c3(%rip), %rax    # 0x5683d6
jmp 0x211c44
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211c29
leaq 0x24d2c0(%rip), %rax    # 0x45eee7
jmp 0x211c44
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211c3d
leaq 0x87f99(%rip), %rax     # 0x299bd4
jmp 0x211c44
leaq 0x166a04(%rip), %rax    # 0x378648
movq %rax, 0x590c35(%rip)    # 0x7a2880
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211c9e
leaq 0x359f35(%rip), %rax    # 0x56bbd1
jmp 0x211ccd
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211cb2
leaq 0x25052b(%rip), %rax    # 0x4621db
jmp 0x211ccd
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211cc6
leaq 0x87f10(%rip), %rax     # 0x299bd4
jmp 0x211ccd
leaq 0x16a342(%rip), %rax    # 0x37c00f
movq %rax, 0x590bb4(%rip)    # 0x7a2888
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211d27
leaq 0x35da5b(%rip), %rax    # 0x56f780
jmp 0x211d56
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211d3b
leaq 0x25390f(%rip), %rax    # 0x465648
jmp 0x211d56
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211d4f
leaq 0x87e87(%rip), %rax     # 0x299bd4
jmp 0x211d56
leaq 0x16db7c(%rip), %rax    # 0x37f8d2
movq %rax, 0x590b33(%rip)    # 0x7a2890
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211db0
leaq 0x36186b(%rip), %rax    # 0x573619
jmp 0x211ddf
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211dc4
leaq 0x257731(%rip), %rax    # 0x4694f3
jmp 0x211ddf
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211dd8
leaq 0x87dfe(%rip), %rax     # 0x299bd4
jmp 0x211ddf
leaq 0x171dfe(%rip), %rax    # 0x383bdd
movq %rax, 0x590ab2(%rip)    # 0x7a2898
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211e39
leaq 0x34042b(%rip), %rax    # 0x552262
jmp 0x211e68
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211e4d
leaq 0x23b820(%rip), %rax    # 0x44d66b
jmp 0x211e68
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211e61
leaq 0x87d75(%rip), %rax     # 0x299bd4
jmp 0x211e68
leaq 0x153ac5(%rip), %rax    # 0x36592d
movq %rax, 0x590a31(%rip)    # 0x7a28a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211ec2
leaq 0x3449d6(%rip), %rax    # 0x556896
jmp 0x211ef1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211ed6
leaq 0x23f617(%rip), %rax    # 0x4514eb
jmp 0x211ef1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211eea
leaq 0x87cec(%rip), %rax     # 0x299bd4
jmp 0x211ef1
leaq 0x157dbc(%rip), %rax    # 0x369cad
movq %rax, 0x5909b0(%rip)    # 0x7a28a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_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_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211f4b
leaq 0x349b60(%rip), %rax    # 0x55baa9
jmp 0x211f7a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211f5f
leaq 0x2439d5(%rip), %rax    # 0x455932
jmp 0x211f7a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211f73
leaq 0x87c63(%rip), %rax     # 0x299bd4
jmp 0x211f7a
leaq 0x15c3c2(%rip), %rax    # 0x36e33c
movq %rax, 0x59092f(%rip)    # 0x7a28b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_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_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x211fd4
leaq 0x350fe4(%rip), %rax    # 0x562fb6
jmp 0x212003
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x211fe8
leaq 0x248cf8(%rip), %rax    # 0x45acde
jmp 0x212003
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x211ffc
leaq 0x87bda(%rip), %rax     # 0x299bd4
jmp 0x212003
leaq 0x161d71(%rip), %rax    # 0x373d74
movq %rax, 0x5908ae(%rip)    # 0x7a28b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_scan_64_pointer = parasail_sg_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_trace_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21205d
leaq 0x364873(%rip), %rax    # 0x5768ce
jmp 0x21208c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x212071
leaq 0x25a113(%rip), %rax    # 0x46c182
jmp 0x21208c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x212085
leaq 0x889cf(%rip), %rax     # 0x29aa52
jmp 0x21208c
leaq 0x174b59(%rip), %rax    # 0x386be5
movq %rax, 0x59082d(%rip)    # 0x7a28c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax