LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_diag_16_pointer = parasail_sw_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_diag_16_pointer = parasail_sw_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_diag_16_pointer = parasail_sw_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_diag_16_pointer = parasail_sw_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_diag_16_pointer = parasail_sw_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_table_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db4ae
leaq 0x8910ab(%rip), %rax    # 0xa6c550
movq %rax, 0xc4c7a4(%rip)    # 0xe27c50
jmp 0x1db4f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db4ca
leaq 0x520fdf(%rip), %rax    # 0x6fc4a0
movq %rax, 0xc4c788(%rip)    # 0xe27c50
jmp 0x1db4f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db4e6
leaq 0x23f2e3(%rip), %rax    # 0x41a7c0
movq %rax, 0xc4c76c(%rip)    # 0xe27c50
jmp 0x1db4f4
leaq 0xbc2b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c75c(%rip)    # 0xe27c50
jmp 0x1db4f6
jmp 0x1db4f8
movq 0xc4c751(%rip), %rax    # 0xe27c50
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_diag_8_pointer = parasail_sw_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_diag_8_pointer = parasail_sw_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_diag_8_pointer = parasail_sw_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_diag_8_pointer = parasail_sw_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_diag_8_pointer = parasail_sw_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_table_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db56e
leaq 0x8a9adb(%rip), %rax    # 0xa85040
movq %rax, 0xc4c6ec(%rip)    # 0xe27c58
jmp 0x1db5b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db58a
leaq 0x53003f(%rip), %rax    # 0x70b5c0
movq %rax, 0xc4c6d0(%rip)    # 0xe27c58
jmp 0x1db5b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db5a6
leaq 0x24e1b3(%rip), %rax    # 0x429750
movq %rax, 0xc4c6b4(%rip)    # 0xe27c58
jmp 0x1db5b4
leaq 0xbc1f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c6a4(%rip)    # 0xe27c58
jmp 0x1db5b6
jmp 0x1db5b8
movq 0xc4c699(%rip), %rax    # 0xe27c58
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_scan_64_pointer = parasail_sw_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_scan_64_pointer = parasail_sw_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_scan_64_pointer = parasail_sw_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_scan_64_pointer = parasail_sw_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_scan_64_pointer = parasail_sw_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_rowcol_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db62e
leaq 0x8eb4bb(%rip), %rax    # 0xac6ae0
movq %rax, 0xc4c634(%rip)    # 0xe27c60
jmp 0x1db678
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db64a
leaq 0x56311f(%rip), %rax    # 0x73e760
movq %rax, 0xc4c618(%rip)    # 0xe27c60
jmp 0x1db676
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db666
leaq 0x27f3f3(%rip), %rax    # 0x45aa50
movq %rax, 0xc4c5fc(%rip)    # 0xe27c60
jmp 0x1db674
leaq 0xbe093(%rip), %rax     # 0x299700
movq %rax, 0xc4c5ec(%rip)    # 0xe27c60
jmp 0x1db676
jmp 0x1db678
movq 0xc4c5e1(%rip), %rax    # 0xe27c60
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_scan_32_pointer = parasail_sw_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_scan_32_pointer = parasail_sw_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_scan_32_pointer = parasail_sw_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_scan_32_pointer = parasail_sw_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_scan_32_pointer = parasail_sw_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_rowcol_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db6ee
leaq 0x8f1fcb(%rip), %rax    # 0xacd6b0
movq %rax, 0xc4c57c(%rip)    # 0xe27c68
jmp 0x1db738
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db70a
leaq 0x5687af(%rip), %rax    # 0x743eb0
movq %rax, 0xc4c560(%rip)    # 0xe27c68
jmp 0x1db736
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db726
leaq 0x284d23(%rip), %rax    # 0x460440
movq %rax, 0xc4c544(%rip)    # 0xe27c68
jmp 0x1db734
leaq 0xbdfd3(%rip), %rax     # 0x299700
movq %rax, 0xc4c534(%rip)    # 0xe27c68
jmp 0x1db736
jmp 0x1db738
movq 0xc4c529(%rip), %rax    # 0xe27c68
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_scan_16_pointer = parasail_sw_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_scan_16_pointer = parasail_sw_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_scan_16_pointer = parasail_sw_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_scan_16_pointer = parasail_sw_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_scan_16_pointer = parasail_sw_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_rowcol_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db7ae
leaq 0x8f9cfb(%rip), %rax    # 0xad54a0
movq %rax, 0xc4c4c4(%rip)    # 0xe27c70
jmp 0x1db7f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db7ca
leaq 0x56e4df(%rip), %rax    # 0x749ca0
movq %rax, 0xc4c4a8(%rip)    # 0xe27c70
jmp 0x1db7f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db7e6
leaq 0x28abd3(%rip), %rax    # 0x4663b0
movq %rax, 0xc4c48c(%rip)    # 0xe27c70
jmp 0x1db7f4
leaq 0xbdf13(%rip), %rax     # 0x299700
movq %rax, 0xc4c47c(%rip)    # 0xe27c70
jmp 0x1db7f6
jmp 0x1db7f8
movq 0xc4c471(%rip), %rax    # 0xe27c70
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_scan_8_pointer = parasail_sw_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_scan_8_pointer = parasail_sw_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_scan_8_pointer = parasail_sw_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_scan_8_pointer = parasail_sw_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_scan_8_pointer = parasail_sw_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_rowcol_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db86e
leaq 0x903c2b(%rip), %rax    # 0xadf490
movq %rax, 0xc4c40c(%rip)    # 0xe27c78
jmp 0x1db8b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db88a
leaq 0x574d3f(%rip), %rax    # 0x7505c0
movq %rax, 0xc4c3f0(%rip)    # 0xe27c78
jmp 0x1db8b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db8a6
leaq 0x291753(%rip), %rax    # 0x46cff0
movq %rax, 0xc4c3d4(%rip)    # 0xe27c78
jmp 0x1db8b4
leaq 0xbde53(%rip), %rax     # 0x299700
movq %rax, 0xc4c3c4(%rip)    # 0xe27c78
jmp 0x1db8b6
jmp 0x1db8b8
movq 0xc4c3b9(%rip), %rax    # 0xe27c78
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_striped_64_pointer = parasail_sw_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_striped_64_pointer = parasail_sw_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_striped_64_pointer = parasail_sw_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_striped_64_pointer = parasail_sw_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_striped_64_pointer = parasail_sw_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_rowcol_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db92e
leaq 0x940b8b(%rip), %rax    # 0xb1c4b0
movq %rax, 0xc4c354(%rip)    # 0xe27c80
jmp 0x1db978
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1db94a
leaq 0x59b9cf(%rip), %rax    # 0x777310
movq %rax, 0xc4c338(%rip)    # 0xe27c80
jmp 0x1db976
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1db966
leaq 0x2b9523(%rip), %rax    # 0x494e80
movq %rax, 0xc4c31c(%rip)    # 0xe27c80
jmp 0x1db974
leaq 0xbbe33(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c30c(%rip)    # 0xe27c80
jmp 0x1db976
jmp 0x1db978
movq 0xc4c301(%rip), %rax    # 0xe27c80
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_striped_32_pointer = parasail_sw_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_striped_32_pointer = parasail_sw_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_striped_32_pointer = parasail_sw_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_striped_32_pointer = parasail_sw_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_striped_32_pointer = parasail_sw_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_rowcol_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1db9ee
leaq 0x9467eb(%rip), %rax    # 0xb221d0
movq %rax, 0xc4c29c(%rip)    # 0xe27c88
jmp 0x1dba38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dba0a
leaq 0x5a082f(%rip), %rax    # 0x77c230
movq %rax, 0xc4c280(%rip)    # 0xe27c88
jmp 0x1dba36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dba26
leaq 0x2be5c3(%rip), %rax    # 0x499fe0
movq %rax, 0xc4c264(%rip)    # 0xe27c88
jmp 0x1dba34
leaq 0xbbd73(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c254(%rip)    # 0xe27c88
jmp 0x1dba36
jmp 0x1dba38
movq 0xc4c249(%rip), %rax    # 0xe27c88
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_striped_16_pointer = parasail_sw_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_striped_16_pointer = parasail_sw_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_striped_16_pointer = parasail_sw_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_striped_16_pointer = parasail_sw_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_striped_16_pointer = parasail_sw_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_rowcol_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbaae
leaq 0x94d15b(%rip), %rax    # 0xb28c00
movq %rax, 0xc4c1e4(%rip)    # 0xe27c90
jmp 0x1dbaf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dbaca
leaq 0x5a5c1f(%rip), %rax    # 0x7816e0
movq %rax, 0xc4c1c8(%rip)    # 0xe27c90
jmp 0x1dbaf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dbae6
leaq 0x2c3ac3(%rip), %rax    # 0x49f5a0
movq %rax, 0xc4c1ac(%rip)    # 0xe27c90
jmp 0x1dbaf4
leaq 0xbbcb3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c19c(%rip)    # 0xe27c90
jmp 0x1dbaf6
jmp 0x1dbaf8
movq 0xc4c191(%rip), %rax    # 0xe27c90
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_striped_8_pointer = parasail_sw_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_striped_8_pointer = parasail_sw_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_striped_8_pointer = parasail_sw_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_striped_8_pointer = parasail_sw_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_striped_8_pointer = parasail_sw_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_rowcol_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbb6e
leaq 0x95558b(%rip), %rax    # 0xb310f0
movq %rax, 0xc4c12c(%rip)    # 0xe27c98
jmp 0x1dbbb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dbb8a
leaq 0x5abbbf(%rip), %rax    # 0x787740
movq %rax, 0xc4c110(%rip)    # 0xe27c98
jmp 0x1dbbb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dbba6
leaq 0x2c9d73(%rip), %rax    # 0x4a5910
movq %rax, 0xc4c0f4(%rip)    # 0xe27c98
jmp 0x1dbbb4
leaq 0xbbbf3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c0e4(%rip)    # 0xe27c98
jmp 0x1dbbb6
jmp 0x1dbbb8
movq 0xc4c0d9(%rip), %rax    # 0xe27c98
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_diag_64_pointer = parasail_sw_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_diag_64_pointer = parasail_sw_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_diag_64_pointer = parasail_sw_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_diag_64_pointer = parasail_sw_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_diag_64_pointer = parasail_sw_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_rowcol_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbc2e
leaq 0x90c38b(%rip), %rax    # 0xae7fb0
movq %rax, 0xc4c074(%rip)    # 0xe27ca0
jmp 0x1dbc78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dbc4a
leaq 0x57a8df(%rip), %rax    # 0x756520
movq %rax, 0xc4c058(%rip)    # 0xe27ca0
jmp 0x1dbc76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dbc66
leaq 0x2974a3(%rip), %rax    # 0x473100
movq %rax, 0xc4c03c(%rip)    # 0xe27ca0
jmp 0x1dbc74
leaq 0xbbb33(%rip), %rax     # 0x2977a0
movq %rax, 0xc4c02c(%rip)    # 0xe27ca0
jmp 0x1dbc76
jmp 0x1dbc78
movq 0xc4c021(%rip), %rax    # 0xe27ca0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_rowcol_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbcee
leaq 0x91507b(%rip), %rax    # 0xaf0d60
movq %rax, 0xc4bfbc(%rip)    # 0xe27ca8
jmp 0x1dbd38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dbd0a
leaq 0x580abf(%rip), %rax    # 0x75c7c0
movq %rax, 0xc4bfa0(%rip)    # 0xe27ca8
jmp 0x1dbd36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dbd26
leaq 0x29d9b3(%rip), %rax    # 0x4796d0
movq %rax, 0xc4bf84(%rip)    # 0xe27ca8
jmp 0x1dbd34
leaq 0xbba73(%rip), %rax     # 0x2977a0
movq %rax, 0xc4bf74(%rip)    # 0xe27ca8
jmp 0x1dbd36
jmp 0x1dbd38
movq 0xc4bf69(%rip), %rax    # 0xe27ca8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_rowcol_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbdae
leaq 0x9218eb(%rip), %rax    # 0xafd690
movq %rax, 0xc4bf04(%rip)    # 0xe27cb0
jmp 0x1dbdf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dbdca
leaq 0x5887df(%rip), %rax    # 0x7645a0
movq %rax, 0xc4bee8(%rip)    # 0xe27cb0
jmp 0x1dbdf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dbde6
leaq 0x2a5943(%rip), %rax    # 0x481720
movq %rax, 0xc4becc(%rip)    # 0xe27cb0
jmp 0x1dbdf4
leaq 0xbb9b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4bebc(%rip)    # 0xe27cb0
jmp 0x1dbdf6
jmp 0x1dbdf8
movq 0xc4beb1(%rip), %rax    # 0xe27cb0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_rowcol_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbe6e
leaq 0x93533b(%rip), %rax    # 0xb111a0
movq %rax, 0xc4be4c(%rip)    # 0xe27cb8
jmp 0x1dbeb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dbe8a
leaq 0x59397f(%rip), %rax    # 0x76f800
movq %rax, 0xc4be30(%rip)    # 0xe27cb8
jmp 0x1dbeb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dbea6
leaq 0x2b1183(%rip), %rax    # 0x48d020
movq %rax, 0xc4be14(%rip)    # 0xe27cb8
jmp 0x1dbeb4
leaq 0xbb8f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4be04(%rip)    # 0xe27cb8
jmp 0x1dbeb6
jmp 0x1dbeb8
movq 0xc4bdf9(%rip), %rax    # 0xe27cb8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbf2e
leaq 0x96144b(%rip), %rax    # 0xb3d370
movq %rax, 0xc4bd94(%rip)    # 0xe27cc0
jmp 0x1dbf78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dbf4a
leaq 0x5b6e3f(%rip), %rax    # 0x792d80
movq %rax, 0xc4bd78(%rip)    # 0xe27cc0
jmp 0x1dbf76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dbf66
leaq 0x2d2d43(%rip), %rax    # 0x4aeca0
movq %rax, 0xc4bd5c(%rip)    # 0xe27cc0
jmp 0x1dbf74
leaq 0xbd793(%rip), %rax     # 0x299700
movq %rax, 0xc4bd4c(%rip)    # 0xe27cc0
jmp 0x1dbf76
jmp 0x1dbf78
movq 0xc4bd41(%rip), %rax    # 0xe27cc0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dbfee
leaq 0x96f4bb(%rip), %rax    # 0xb4b4a0
movq %rax, 0xc4bcdc(%rip)    # 0xe27cc8
jmp 0x1dc038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc00a
leaq 0x5c22ff(%rip), %rax    # 0x79e300
movq %rax, 0xc4bcc0(%rip)    # 0xe27cc8
jmp 0x1dc036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc026
leaq 0x2dd5e3(%rip), %rax    # 0x4b9600
movq %rax, 0xc4bca4(%rip)    # 0xe27cc8
jmp 0x1dc034
leaq 0xbd6d3(%rip), %rax     # 0x299700
movq %rax, 0xc4bc94(%rip)    # 0xe27cc8
jmp 0x1dc036
jmp 0x1dc038
movq 0xc4bc89(%rip), %rax    # 0xe27cc8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dc0ae
leaq 0x97eecb(%rip), %rax    # 0xb5af70
movq %rax, 0xc4bc24(%rip)    # 0xe27cd0
jmp 0x1dc0f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc0ca
leaq 0x5ce06f(%rip), %rax    # 0x7aa130
movq %rax, 0xc4bc08(%rip)    # 0xe27cd0
jmp 0x1dc0f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc0e6
leaq 0x2e85f3(%rip), %rax    # 0x4c46d0
movq %rax, 0xc4bbec(%rip)    # 0xe27cd0
jmp 0x1dc0f4
leaq 0xbd613(%rip), %rax     # 0x299700
movq %rax, 0xc4bbdc(%rip)    # 0xe27cd0
jmp 0x1dc0f6
jmp 0x1dc0f8
movq 0xc4bbd1(%rip), %rax    # 0xe27cd0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dc16e
leaq 0x99180b(%rip), %rax    # 0xb6d970
movq %rax, 0xc4bb6c(%rip)    # 0xe27cd8
jmp 0x1dc1b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc18a
leaq 0x5dabff(%rip), %rax    # 0x7b6d80
movq %rax, 0xc4bb50(%rip)    # 0xe27cd8
jmp 0x1dc1b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc1a6
leaq 0x2f45e3(%rip), %rax    # 0x4d0780
movq %rax, 0xc4bb34(%rip)    # 0xe27cd8
jmp 0x1dc1b4
leaq 0xbd553(%rip), %rax     # 0x299700
movq %rax, 0xc4bb24(%rip)    # 0xe27cd8
jmp 0x1dc1b6
jmp 0x1dc1b8
movq 0xc4bb19(%rip), %rax    # 0xe27cd8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dc22e
leaq 0x9eb40b(%rip), %rax    # 0xbc7630
movq %rax, 0xc4bab4(%rip)    # 0xe27ce0
jmp 0x1dc278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc24a
leaq 0x61792f(%rip), %rax    # 0x7f3b70
movq %rax, 0xc4ba98(%rip)    # 0xe27ce0
jmp 0x1dc276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc266
leaq 0x32f9d3(%rip), %rax    # 0x50bc30
movq %rax, 0xc4ba7c(%rip)    # 0xe27ce0
jmp 0x1dc274
leaq 0xbb533(%rip), %rax     # 0x2977a0
movq %rax, 0xc4ba6c(%rip)    # 0xe27ce0
jmp 0x1dc276
jmp 0x1dc278
movq 0xc4ba61(%rip), %rax    # 0xe27ce0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dc2ee
leaq 0x9f702b(%rip), %rax    # 0xbd3310
movq %rax, 0xc4b9fc(%rip)    # 0xe27ce8
jmp 0x1dc338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc30a
leaq 0x62172f(%rip), %rax    # 0x7fda30
movq %rax, 0xc4b9e0(%rip)    # 0xe27ce8
jmp 0x1dc336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc326
leaq 0x339223(%rip), %rax    # 0x515540
movq %rax, 0xc4b9c4(%rip)    # 0xe27ce8
jmp 0x1dc334
leaq 0xbb473(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b9b4(%rip)    # 0xe27ce8
jmp 0x1dc336
jmp 0x1dc338
movq 0xc4b9a9(%rip), %rax    # 0xe27ce8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)