LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2327b6
leaq 0x2e17ee(%rip), %rax    # 0x513fa2
jmp 0x2327e5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2327ca
leaq 0x1e6d45(%rip), %rax    # 0x41950d
jmp 0x2327e5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2327de
leaq 0x6734e(%rip), %rax     # 0x299b2a
jmp 0x2327e5
leaq 0xfb79b(%rip), %rax     # 0x32df80
movq %rax, 0x571e7c(%rip)    # 0x7a4668
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x23283f
leaq 0x2e5e9c(%rip), %rax    # 0x5186d9
jmp 0x23286e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232853
leaq 0x1ea6ab(%rip), %rax    # 0x41cefc
jmp 0x23286e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232867
leaq 0x672c5(%rip), %rax     # 0x299b2a
jmp 0x23286e
leaq 0xff427(%rip), %rax     # 0x331c95
movq %rax, 0x571dfb(%rip)    # 0x7a4670
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2328c8
leaq 0x2ea90d(%rip), %rax    # 0x51d1d3
jmp 0x2328f7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2328dc
leaq 0x1ef396(%rip), %rax    # 0x421c70
jmp 0x2328f7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2328f0
leaq 0x6723c(%rip), %rax     # 0x299b2a
jmp 0x2328f7
leaq 0x1044dd(%rip), %rax    # 0x336dd4
movq %rax, 0x571d7a(%rip)    # 0x7a4678
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x232951
leaq 0x2c7815(%rip), %rax    # 0x4fa164
jmp 0x232980
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232965
leaq 0x1d2708(%rip), %rax    # 0x40506b
jmp 0x232980
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232979
leaq 0x671b3(%rip), %rax     # 0x299b2a
jmp 0x232980
leaq 0xe5461(%rip), %rax     # 0x317de1
movq %rax, 0x571cf9(%rip)    # 0x7a4680
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2329da
leaq 0x2cc274(%rip), %rax    # 0x4fec4c
jmp 0x232a09
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2329ee
leaq 0x1d61c9(%rip), %rax    # 0x408bb5
jmp 0x232a09
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232a02
leaq 0x6712a(%rip), %rax     # 0x299b2a
jmp 0x232a09
leaq 0xe9555(%rip), %rax     # 0x31bf5e
movq %rax, 0x571c78(%rip)    # 0x7a4688
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x232a63
leaq 0x2d15f2(%rip), %rax    # 0x504053
jmp 0x232a92
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232a77
leaq 0x1da377(%rip), %rax    # 0x40cdec
jmp 0x232a92
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232a8b
leaq 0x670a1(%rip), %rax     # 0x299b2a
jmp 0x232a92
leaq 0xeda06(%rip), %rax     # 0x320498
movq %rax, 0x571bf7(%rip)    # 0x7a4690
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x232aec
leaq 0x2d8788(%rip), %rax    # 0x50b272
jmp 0x232b1b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232b00
leaq 0x1df4fb(%rip), %rax    # 0x411ff9
jmp 0x232b1b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232b14
leaq 0x67018(%rip), %rax     # 0x299b2a
jmp 0x232b1b
leaq 0xf324c(%rip), %rax     # 0x325d67
movq %rax, 0x571b76(%rip)    # 0x7a4698
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x232b75
leaq 0x2ed9f3(%rip), %rax    # 0x520566
jmp 0x232ba4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232b89
leaq 0x1f2198(%rip), %rax    # 0x424d1f
jmp 0x232ba4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232b9d
leaq 0x67e0d(%rip), %rax     # 0x29a9a8
jmp 0x232ba4
leaq 0x1076e3(%rip), %rax    # 0x33a287
movq %rax, 0x571af5(%rip)    # 0x7a46a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x232bfe
leaq 0x2ef803(%rip), %rax    # 0x5223ff
jmp 0x232c2d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232c12
leaq 0x1f3b3e(%rip), %rax    # 0x42674e
jmp 0x232c2d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232c26
leaq 0x67d84(%rip), %rax     # 0x29a9a8
jmp 0x232c2d
leaq 0x1092ff(%rip), %rax    # 0x33bf2c
movq %rax, 0x571a74(%rip)    # 0x7a46a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_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_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x232c87
leaq 0x2f1450(%rip), %rax    # 0x5240d5
jmp 0x232cb6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232c9b
leaq 0x1f547e(%rip), %rax    # 0x428117
jmp 0x232cb6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232caf
leaq 0x67cfb(%rip), %rax     # 0x29a9a8
jmp 0x232cb6
leaq 0x10ad5f(%rip), %rax    # 0x33da15
movq %rax, 0x5719f3(%rip)    # 0x7a46b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x232d10
leaq 0x2f3687(%rip), %rax    # 0x526395
jmp 0x232d3f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232d24
leaq 0x1f709b(%rip), %rax    # 0x429dbd
jmp 0x232d3f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232d38
leaq 0x67c72(%rip), %rax     # 0x29a9a8
jmp 0x232d3f
leaq 0x10cbcd(%rip), %rax    # 0x33f90c
movq %rax, 0x571972(%rip)    # 0x7a46b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x232d99
leaq 0x305b3f(%rip), %rax    # 0x5388d6
jmp 0x232dc8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232dad
leaq 0x2034ce(%rip), %rax    # 0x436279
jmp 0x232dc8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232dc1
leaq 0x66d6b(%rip), %rax     # 0x299b2a
jmp 0x232dc8
leaq 0x119e5e(%rip), %rax    # 0x34cc26
movq %rax, 0x5718f1(%rip)    # 0x7a46c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x232e22
leaq 0x3075bb(%rip), %rax    # 0x53a3db
jmp 0x232e51
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232e36
leaq 0x204cf9(%rip), %rax    # 0x437b2d
jmp 0x232e51
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232e4a
leaq 0x66ce2(%rip), %rax     # 0x299b2a
jmp 0x232e51
leaq 0x11b7ee(%rip), %rax    # 0x34e63f
movq %rax, 0x571870(%rip)    # 0x7a46c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x232eab
leaq 0x308fcf(%rip), %rax    # 0x53be78
jmp 0x232eda
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232ebf
leaq 0x206455(%rip), %rax    # 0x439312
jmp 0x232eda
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232ed3
leaq 0x66c59(%rip), %rax     # 0x299b2a
jmp 0x232eda
leaq 0x11d010(%rip), %rax    # 0x34feea
movq %rax, 0x5717ef(%rip)    # 0x7a46d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x232f34
leaq 0x30b026(%rip), %rax    # 0x53df58
jmp 0x232f63
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232f48
leaq 0x207eab(%rip), %rax    # 0x43adf1
jmp 0x232f63
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232f5c
leaq 0x66bd0(%rip), %rax     # 0x299b2a
jmp 0x232f63
leaq 0x11ec9f(%rip), %rax    # 0x351c02
movq %rax, 0x57176e(%rip)    # 0x7a46d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x232fbd
leaq 0x2f5cc0(%rip), %rax    # 0x528c7b
jmp 0x232fec
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x232fd1
leaq 0x1f8da2(%rip), %rax    # 0x42bd71
jmp 0x232fec
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x232fe5
leaq 0x66b47(%rip), %rax     # 0x299b2a
jmp 0x232fec
leaq 0x10ebf8(%rip), %rax    # 0x341be4
movq %rax, 0x5716ed(%rip)    # 0x7a46e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x233046
leaq 0x2f84ba(%rip), %rax    # 0x52b4fe
jmp 0x233075
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23305a
leaq 0x1faaea(%rip), %rax    # 0x42db42
jmp 0x233075
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23306e
leaq 0x66abe(%rip), %rax     # 0x299b2a
jmp 0x233075
leaq 0x110cf2(%rip), %rax    # 0x343d67
movq %rax, 0x57166c(%rip)    # 0x7a46e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2330cf
leaq 0x2fbc96(%rip), %rax    # 0x52ed63
jmp 0x2330fe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2330e3
leaq 0x1fcfc1(%rip), %rax    # 0x4300a2
jmp 0x2330fe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2330f7
leaq 0x66a35(%rip), %rax     # 0x299b2a
jmp 0x2330fe
leaq 0x1133f2(%rip), %rax    # 0x3464f0
movq %rax, 0x5715eb(%rip)    # 0x7a46f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x233158
leaq 0x301a4d(%rip), %rax    # 0x534ba3
jmp 0x233187
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23316c
leaq 0x20081c(%rip), %rax    # 0x433986
jmp 0x233187
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x233180
leaq 0x669ac(%rip), %rax     # 0x299b2a
jmp 0x233187
leaq 0x116f1c(%rip), %rax    # 0x34a0a3
movq %rax, 0x57156a(%rip)    # 0x7a46f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2331e1
leaq 0x30e9c2(%rip), %rax    # 0x541ba1
jmp 0x233210
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2331f5
leaq 0x20b4ff(%rip), %rax    # 0x43e6f2
jmp 0x233210
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x233209
leaq 0x677a1(%rip), %rax     # 0x29a9a8
jmp 0x233210
leaq 0x122010(%rip), %rax    # 0x355220
movq %rax, 0x5714e9(%rip)    # 0x7a4700
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x23326a
leaq 0x3125d0(%rip), %rax    # 0x545838
jmp 0x233299
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x23327e
leaq 0x20eae8(%rip), %rax    # 0x441d64
jmp 0x233299
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x233292
leaq 0x67718(%rip), %rax     # 0x29a9a8
jmp 0x233299
leaq 0x125c9c(%rip), %rax    # 0x358f35
movq %rax, 0x571468(%rip)    # 0x7a4708
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x2332f3
leaq 0x3165f1(%rip), %rax    # 0x5498e2
jmp 0x233322
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x233307
leaq 0x21226a(%rip), %rax    # 0x44556f
jmp 0x233322
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x23331b
leaq 0x6768f(%rip), %rax     # 0x29a9a8
jmp 0x233322
leaq 0x129898(%rip), %rax    # 0x35cbba
movq %rax, 0x5713e7(%rip)    # 0x7a4710
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