LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_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_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x5672cf
testl %eax, %eax
je 0x1b3fd9
leaq 0x33d2e7(%rip), %rax    # 0x4f12be
jmp 0x1b4008
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3fed
leaq 0x239890(%rip), %rax    # 0x3ed87b
jmp 0x1b4008
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4001
leaq 0x899cd(%rip), %rax     # 0x23d9cc
jmp 0x1b4008
leaq 0x13b11a(%rip), %rax    # 0x2ef122
movq %rax, 0x5877f1(%rip)    # 0x73b800
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_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_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_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x5672cf
testl %eax, %eax
je 0x1b4062
leaq 0x33f173(%rip), %rax    # 0x4f31d3
jmp 0x1b4091
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4076
leaq 0x23b554(%rip), %rax    # 0x3ef5c8
jmp 0x1b4091
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b408a
leaq 0x89944(%rip), %rax     # 0x23d9cc
jmp 0x1b4091
leaq 0x13d2ad(%rip), %rax    # 0x2f133e
movq %rax, 0x587770(%rip)    # 0x73b808
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_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_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_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x5672cf
testl %eax, %eax
je 0x1b40eb
leaq 0x341212(%rip), %rax    # 0x4f52fb
jmp 0x1b411a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b40ff
leaq 0x23d354(%rip), %rax    # 0x3f1451
jmp 0x1b411a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4113
leaq 0x898bb(%rip), %rax     # 0x23d9cc
jmp 0x1b411a
leaq 0x13f221(%rip), %rax    # 0x2f333b
movq %rax, 0x5876ef(%rip)    # 0x73b810
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4174
leaq 0x3437de(%rip), %rax    # 0x4f7950
jmp 0x1b41a3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4188
leaq 0x23f39a(%rip), %rax    # 0x3f3520
jmp 0x1b41a3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b419c
leaq 0x89832(%rip), %rax     # 0x23d9cc
jmp 0x1b41a3
leaq 0x141533(%rip), %rax    # 0x2f56d6
movq %rax, 0x58766e(%rip)    # 0x73b818
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b41fd
leaq 0x355711(%rip), %rax    # 0x50990c
jmp 0x1b422c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4211
leaq 0x24be28(%rip), %rax    # 0x400037
jmp 0x1b422c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4225
leaq 0x8873b(%rip), %rax     # 0x23c95e
jmp 0x1b422c
leaq 0x14fd31(%rip), %rax    # 0x303f5d
movq %rax, 0x5875ed(%rip)    # 0x73b820
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4286
leaq 0x35738b(%rip), %rax    # 0x50b60f
jmp 0x1b42b5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b429a
leaq 0x24d986(%rip), %rax    # 0x401c1e
jmp 0x1b42b5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b42ae
leaq 0x886b2(%rip), %rax     # 0x23c95e
jmp 0x1b42b5
leaq 0x151cf8(%rip), %rax    # 0x305fad
movq %rax, 0x58756c(%rip)    # 0x73b828
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b430f
leaq 0x359197(%rip), %rax    # 0x50d4a4
jmp 0x1b433e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4323
leaq 0x24f514(%rip), %rax    # 0x403835
jmp 0x1b433e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4337
leaq 0x88629(%rip), %rax     # 0x23c95e
jmp 0x1b433e
leaq 0x1539c4(%rip), %rax    # 0x307d02
movq %rax, 0x5874eb(%rip)    # 0x73b830
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4398
leaq 0x35b56a(%rip), %rax    # 0x50f900
jmp 0x1b43c7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b43ac
leaq 0x25133e(%rip), %rax    # 0x4056e8
jmp 0x1b43c7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b43c0
leaq 0x885a0(%rip), %rax     # 0x23c95e
jmp 0x1b43c7
leaq 0x155a9e(%rip), %rax    # 0x309e65
movq %rax, 0x58746a(%rip)    # 0x73b838
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4421
leaq 0x345d37(%rip), %rax    # 0x4fa156
jmp 0x1b4450
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4435
leaq 0x241260(%rip), %rax    # 0x3f5693
jmp 0x1b4450
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4449
leaq 0x88517(%rip), %rax     # 0x23c95e
jmp 0x1b4450
leaq 0x143a9a(%rip), %rax    # 0x2f7eea
movq %rax, 0x5873e9(%rip)    # 0x73b840
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b44aa
leaq 0x3484ad(%rip), %rax    # 0x4fc955
jmp 0x1b44d9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b44be
leaq 0x243093(%rip), %rax    # 0x3f754f
jmp 0x1b44d9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b44d2
leaq 0x8848e(%rip), %rax     # 0x23c95e
jmp 0x1b44d9
leaq 0x145d51(%rip), %rax    # 0x2fa22a
movq %rax, 0x587368(%rip)    # 0x73b848
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4533
leaq 0x34bd75(%rip), %rax    # 0x5002a6
jmp 0x1b4562
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4547
leaq 0x24566b(%rip), %rax    # 0x3f9bb0
jmp 0x1b4562
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b455b
leaq 0x88405(%rip), %rax     # 0x23c95e
jmp 0x1b4562
leaq 0x148653(%rip), %rax    # 0x2fcbb5
movq %rax, 0x5872e7(%rip)    # 0x73b850
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b45bc
leaq 0x351a86(%rip), %rax    # 0x506040
jmp 0x1b45eb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b45d0
leaq 0x248e61(%rip), %rax    # 0x3fd42f
jmp 0x1b45eb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b45e4
leaq 0x8837c(%rip), %rax     # 0x23c95e
jmp 0x1b45eb
leaq 0x14c5f2(%rip), %rax    # 0x300bdd
movq %rax, 0x587266(%rip)    # 0x73b858
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4645
leaq 0x35f2b0(%rip), %rax    # 0x5138f3
jmp 0x1b4674
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4659
leaq 0x2551ae(%rip), %rax    # 0x409805
jmp 0x1b4674
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b466d
leaq 0x89361(%rip), %rax     # 0x23d9cc
jmp 0x1b4674
leaq 0x159b2c(%rip), %rax    # 0x30e1a0
movq %rax, 0x5871e5(%rip)    # 0x73b860
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b46ce
leaq 0x363232(%rip), %rax    # 0x5178fe
jmp 0x1b46fd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b46e2
leaq 0x258de8(%rip), %rax    # 0x40d4c8
jmp 0x1b46fd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b46f6
leaq 0x892d8(%rip), %rax     # 0x23d9cc
jmp 0x1b46fd
leaq 0x15e0c6(%rip), %rax    # 0x3127c3
movq %rax, 0x587164(%rip)    # 0x73b868
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4757
leaq 0x366e68(%rip), %rax    # 0x51b5bd
jmp 0x1b4786
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b476b
leaq 0x25c850(%rip), %rax    # 0x410fb9
jmp 0x1b4786
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b477f
leaq 0x8924f(%rip), %rax     # 0x23d9cc
jmp 0x1b4786
leaq 0x161fb3(%rip), %rax    # 0x316739
movq %rax, 0x5870e3(%rip)    # 0x73b870
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b47e0
leaq 0x36ae90(%rip), %rax    # 0x51f66e
jmp 0x1b480f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b47f4
leaq 0x2604e3(%rip), %rax    # 0x414cd5
jmp 0x1b480f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4808
leaq 0x891c6(%rip), %rax     # 0x23d9cc
jmp 0x1b480f
leaq 0x1661d7(%rip), %rax    # 0x31a9e6
movq %rax, 0x587062(%rip)    # 0x73b878
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4869
leaq 0x384757(%rip), %rax    # 0x538fbe
jmp 0x1b4898
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b487d
leaq 0x275c3d(%rip), %rax    # 0x42a4b8
jmp 0x1b4898
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4891
leaq 0x880cf(%rip), %rax     # 0x23c95e
jmp 0x1b4898
leaq 0x17e82e(%rip), %rax    # 0x3330c6
movq %rax, 0x586fe1(%rip)    # 0x73b880
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b48f2
leaq 0x3881f8(%rip), %rax    # 0x53cae8
jmp 0x1b4921
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4906
leaq 0x2795eb(%rip), %rax    # 0x42deef
jmp 0x1b4921
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b491a
leaq 0x88046(%rip), %rax     # 0x23c95e
jmp 0x1b4921
leaq 0x182a45(%rip), %rax    # 0x337366
movq %rax, 0x586f60(%rip)    # 0x73b888
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b497b
leaq 0x38bb8a(%rip), %rax    # 0x540503
jmp 0x1b49aa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b498f
leaq 0x27cdae(%rip), %rax    # 0x43173b
jmp 0x1b49aa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b49a3
leaq 0x87fbd(%rip), %rax     # 0x23c95e
jmp 0x1b49aa
leaq 0x1866ba(%rip), %rax    # 0x33b064
movq %rax, 0x586edf(%rip)    # 0x73b890
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4a04
leaq 0x38fa33(%rip), %rax    # 0x544435
jmp 0x1b4a33
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4a18
leaq 0x28083e(%rip), %rax    # 0x435254
jmp 0x1b4a33
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4a2c
leaq 0x87f34(%rip), %rax     # 0x23c95e
jmp 0x1b4a33
leaq 0x18a623(%rip), %rax    # 0x33f056
movq %rax, 0x586e5e(%rip)    # 0x73b898
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4a8d
leaq 0x36ef22(%rip), %rax    # 0x5239ad
jmp 0x1b4abc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4aa1
leaq 0x2642c2(%rip), %rax    # 0x418d61
jmp 0x1b4abc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4ab5
leaq 0x87eab(%rip), %rax     # 0x23c95e
jmp 0x1b4abc
leaq 0x16a98d(%rip), %rax    # 0x31f449
movq %rax, 0x586ddd(%rip)    # 0x73b8a0
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_O2/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 0x5672cf
testl %eax, %eax
je 0x1b4b16
leaq 0x372ff8(%rip), %rax    # 0x527b0c
jmp 0x1b4b45
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b4b2a
leaq 0x267e54(%rip), %rax    # 0x41c97c
jmp 0x1b4b45
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b4b3e
leaq 0x87e22(%rip), %rax     # 0x23c95e
jmp 0x1b4b45
leaq 0x16ed48(%rip), %rax    # 0x32388d
movq %rax, 0x586d5c(%rip)    # 0x73b8a8
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