LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234308
leaq 0x322f53(%rip), %rax    # 0x557259
jmp 0x234337
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23431c
leaq 0x21b5ea(%rip), %rax    # 0x44f904
jmp 0x234337
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234330
leaq 0x680c6(%rip), %rax     # 0x29c3f4
jmp 0x234337
leaq 0x121a49(%rip), %rax    # 0x355d80
movq %rax, 0x5a637a(%rip)    # 0x7da6b8
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234391
leaq 0x333251(%rip), %rax    # 0x5675e0
jmp 0x2343c0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2343a5
leaq 0x226fe0(%rip), %rax    # 0x45b383
jmp 0x2343c0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2343b9
leaq 0x66d41(%rip), %rax     # 0x29b0f8
jmp 0x2343c0
leaq 0x12f03a(%rip), %rax    # 0x3633fa
movq %rax, 0x5a62f9(%rip)    # 0x7da6c0
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x23441a
leaq 0x334a90(%rip), %rax    # 0x568ea8
jmp 0x234449
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x23442e
leaq 0x2287d5(%rip), %rax    # 0x45cc01
jmp 0x234449
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234442
leaq 0x66cb8(%rip), %rax     # 0x29b0f8
jmp 0x234449
leaq 0x130d0b(%rip), %rax    # 0x365154
movq %rax, 0x5a6278(%rip)    # 0x7da6c8
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x2344a3
leaq 0x3370b6(%rip), %rax    # 0x56b557
jmp 0x2344d2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2344b7
leaq 0x22a359(%rip), %rax    # 0x45e80e
jmp 0x2344d2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2344cb
leaq 0x66c2f(%rip), %rax     # 0x29b0f8
jmp 0x2344d2
leaq 0x132cba(%rip), %rax    # 0x36718c
movq %rax, 0x5a61f7(%rip)    # 0x7da6d0
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x23452c
leaq 0x33aaef(%rip), %rax    # 0x56f019
jmp 0x23455b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234540
leaq 0x22c634(%rip), %rax    # 0x460b72
jmp 0x23455b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234554
leaq 0x66ba6(%rip), %rax     # 0x29b0f8
jmp 0x23455b
leaq 0x135799(%rip), %rax    # 0x369cf4
movq %rax, 0x5a6176(%rip)    # 0x7da6d8
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x2345b5
leaq 0x324fa5(%rip), %rax    # 0x559558
jmp 0x2345e4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2345c9
leaq 0x21d0f6(%rip), %rax    # 0x4516bd
jmp 0x2345e4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2345dd
leaq 0x66b1d(%rip), %rax     # 0x29b0f8
jmp 0x2345e4
leaq 0x123bd0(%rip), %rax    # 0x3581b4
movq %rax, 0x5a60f5(%rip)    # 0x7da6e0
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x23463e
leaq 0x3273de(%rip), %rax    # 0x55ba1a
jmp 0x23466d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234652
leaq 0x21ecb0(%rip), %rax    # 0x453300
jmp 0x23466d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234666
leaq 0x66a94(%rip), %rax     # 0x29b0f8
jmp 0x23466d
leaq 0x125c9e(%rip), %rax    # 0x35a30b
movq %rax, 0x5a6074(%rip)    # 0x7da6e8
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x2346c7
leaq 0x32aa7e(%rip), %rax    # 0x55f143
jmp 0x2346f6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2346db
leaq 0x22106d(%rip), %rax    # 0x455746
jmp 0x2346f6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2346ef
leaq 0x66a0b(%rip), %rax     # 0x29b0f8
jmp 0x2346f6
leaq 0x1282fa(%rip), %rax    # 0x35c9f0
movq %rax, 0x5a5ff3(%rip)    # 0x7da6f0
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234750
leaq 0x33002f(%rip), %rax    # 0x56477d
jmp 0x23477f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234764
leaq 0x22469c(%rip), %rax    # 0x458dfe
jmp 0x23477f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234778
leaq 0x66982(%rip), %rax     # 0x29b0f8
jmp 0x23477f
leaq 0x12bf00(%rip), %rax    # 0x36067f
movq %rax, 0x5a5f72(%rip)    # 0x7da6f8
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x2347d9
leaq 0x33d97c(%rip), %rax    # 0x572153
jmp 0x234808
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2347ed
leaq 0x22f9d0(%rip), %rax    # 0x4641bb
jmp 0x234808
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234801
leaq 0x67bf5(%rip), %rax     # 0x29c3f4
jmp 0x234808
leaq 0x138e70(%rip), %rax    # 0x36d678
movq %rax, 0x5a5ef1(%rip)    # 0x7da700
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234862
leaq 0x341183(%rip), %rax    # 0x5759e3
jmp 0x234891
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234876
leaq 0x232f06(%rip), %rax    # 0x46777a
jmp 0x234891
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23488a
leaq 0x67b6c(%rip), %rax     # 0x29c3f4
jmp 0x234891
leaq 0x13cce1(%rip), %rax    # 0x371572
movq %rax, 0x5a5e70(%rip)    # 0x7da708
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x2348eb
leaq 0x345af5(%rip), %rax    # 0x57a3de
jmp 0x23491a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2348ff
leaq 0x236c29(%rip), %rax    # 0x46b526
jmp 0x23491a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234913
leaq 0x67ae3(%rip), %rax     # 0x29c3f4
jmp 0x23491a
leaq 0x1411e3(%rip), %rax    # 0x375afd
movq %rax, 0x5a5def(%rip)    # 0x7da710
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234974
leaq 0x34aedf(%rip), %rax    # 0x57f851
jmp 0x2349a3
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234988
leaq 0x23b64f(%rip), %rax    # 0x46ffd5
jmp 0x2349a3
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x23499c
leaq 0x67a5a(%rip), %rax     # 0x29c3f4
jmp 0x2349a3
leaq 0x1467f6(%rip), %rax    # 0x37b199
movq %rax, 0x5a5d6e(%rip)    # 0x7da718
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x2349fd
leaq 0x363bb1(%rip), %rax    # 0x5985ac
jmp 0x234a2c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234a11
leaq 0x25057b(%rip), %rax    # 0x484f8a
jmp 0x234a2c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234a25
leaq 0x666d5(%rip), %rax     # 0x29b0f8
jmp 0x234a2c
leaq 0x15e441(%rip), %rax    # 0x392e6d
movq %rax, 0x5a5ced(%rip)    # 0x7da720
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234a86
leaq 0x366f70(%rip), %rax    # 0x59b9f4
jmp 0x234ab5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234a9a
leaq 0x2537c7(%rip), %rax    # 0x48825f
jmp 0x234ab5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234aae
leaq 0x6664c(%rip), %rax     # 0x29b0f8
jmp 0x234ab5
leaq 0x162165(%rip), %rax    # 0x396c1a
movq %rax, 0x5a5c6c(%rip)    # 0x7da728
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234b0f
leaq 0x36b6cc(%rip), %rax    # 0x5a01d9
jmp 0x234b3e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234b23
leaq 0x2570ba(%rip), %rax    # 0x48bbdb
jmp 0x234b3e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234b37
leaq 0x665c3(%rip), %rax     # 0x29b0f8
jmp 0x234b3e
leaq 0x1660f1(%rip), %rax    # 0x39ac2f
movq %rax, 0x5a5beb(%rip)    # 0x7da730
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234b98
leaq 0x370e4e(%rip), %rax    # 0x5a59e4
jmp 0x234bc7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234bac
leaq 0x25b7c6(%rip), %rax    # 0x490370
jmp 0x234bc7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234bc0
leaq 0x6653a(%rip), %rax     # 0x29b0f8
jmp 0x234bc7
leaq 0x16b18a(%rip), %rax    # 0x39fd51
movq %rax, 0x5a5b6a(%rip)    # 0x7da738
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234c21
leaq 0x34ed85(%rip), %rax    # 0x5839a4
jmp 0x234c50
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234c35
leaq 0x23f156(%rip), %rax    # 0x473d89
jmp 0x234c50
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234c49
leaq 0x664b1(%rip), %rax     # 0x29b0f8
jmp 0x234c50
leaq 0x14acdd(%rip), %rax    # 0x37f92d
movq %rax, 0x5a5ae9(%rip)    # 0x7da740
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234caa
leaq 0x352deb(%rip), %rax    # 0x587a93
jmp 0x234cd9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234cbe
leaq 0x242caa(%rip), %rax    # 0x477966
jmp 0x234cd9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234cd2
leaq 0x66428(%rip), %rax     # 0x29b0f8
jmp 0x234cd9
leaq 0x14f0f2(%rip), %rax    # 0x383dcb
movq %rax, 0x5a5a68(%rip)    # 0x7da748
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234d33
leaq 0x357fa4(%rip), %rax    # 0x58ccd5
jmp 0x234d62
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234d47
leaq 0x246f0e(%rip), %rax    # 0x47bc53
jmp 0x234d62
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234d5b
leaq 0x6639f(%rip), %rax     # 0x29b0f8
jmp 0x234d62
leaq 0x15365a(%rip), %rax    # 0x3883bc
movq %rax, 0x5a59e7(%rip)    # 0x7da750
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_O3/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x5c8fdb
testl %eax, %eax
je 0x234dbc
leaq 0x35eeaf(%rip), %rax    # 0x593c69
jmp 0x234deb
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x234dd0
leaq 0x24c32b(%rip), %rax    # 0x4810f9
jmp 0x234deb
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x234de4
leaq 0x66316(%rip), %rax     # 0x29b0f8
jmp 0x234deb
leaq 0x159344(%rip), %rax    # 0x38e12f
movq %rax, 0x5a5966(%rip)    # 0x7da758
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