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_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x1dc3ae
leaq 0xa03cbb(%rip), %rax    # 0xbe0060
movq %rax, 0xc4b944(%rip)    # 0xe27cf0
jmp 0x1dc3f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc3ca
leaq 0x62bccf(%rip), %rax    # 0x808090
movq %rax, 0xc4b928(%rip)    # 0xe27cf0
jmp 0x1dc3f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc3e6
leaq 0x342fe3(%rip), %rax    # 0x51f3c0
movq %rax, 0xc4b90c(%rip)    # 0xe27cf0
jmp 0x1dc3f4
leaq 0xbb3b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b8fc(%rip)    # 0xe27cf0
jmp 0x1dc3f6
jmp 0x1dc3f8
movq 0xc4b8f1(%rip), %rax    # 0xe27cf0
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_8_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x1dc46e
leaq 0xa12a5b(%rip), %rax    # 0xbeeec0
movq %rax, 0xc4b88c(%rip)    # 0xe27cf8
jmp 0x1dc4b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc48a
leaq 0x63729f(%rip), %rax    # 0x813720
movq %rax, 0xc4b870(%rip)    # 0xe27cf8
jmp 0x1dc4b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc4a6
leaq 0x34ddb3(%rip), %rax    # 0x52a250
movq %rax, 0xc4b854(%rip)    # 0xe27cf8
jmp 0x1dc4b4
leaq 0xbb2f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b844(%rip)    # 0xe27cf8
jmp 0x1dc4b6
jmp 0x1dc4b8
movq 0xc4b839(%rip), %rax    # 0xe27cf8
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_diag_64_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x1dc52e
leaq 0x9a060b(%rip), %rax    # 0xb7cb30
movq %rax, 0xc4b7d4(%rip)    # 0xe27d00
jmp 0x1dc578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc54a
leaq 0x5e540f(%rip), %rax    # 0x7c1950
movq %rax, 0xc4b7b8(%rip)    # 0xe27d00
jmp 0x1dc576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc566
leaq 0x2fe5e3(%rip), %rax    # 0x4dab40
movq %rax, 0xc4b79c(%rip)    # 0xe27d00
jmp 0x1dc574
leaq 0xbb233(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b78c(%rip)    # 0xe27d00
jmp 0x1dc576
jmp 0x1dc578
movq 0xc4b781(%rip), %rax    # 0xe27d00
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_diag_32_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x1dc5ee
leaq 0x9ae4fb(%rip), %rax    # 0xb8aae0
movq %rax, 0xc4b71c(%rip)    # 0xe27d08
jmp 0x1dc638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc60a
leaq 0x5ef63f(%rip), %rax    # 0x7cbc40
movq %rax, 0xc4b700(%rip)    # 0xe27d08
jmp 0x1dc636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc626
leaq 0x308363(%rip), %rax    # 0x4e4980
movq %rax, 0xc4b6e4(%rip)    # 0xe27d08
jmp 0x1dc634
leaq 0xbb173(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b6d4(%rip)    # 0xe27d08
jmp 0x1dc636
jmp 0x1dc638
movq 0xc4b6c9(%rip), %rax    # 0xe27d08
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_diag_16_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x1dc6ae
leaq 0x9c040b(%rip), %rax    # 0xb9cab0
movq %rax, 0xc4b664(%rip)    # 0xe27d10
jmp 0x1dc6f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc6ca
leaq 0x5fb60f(%rip), %rax    # 0x7d7cd0
movq %rax, 0xc4b648(%rip)    # 0xe27d10
jmp 0x1dc6f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc6e6
leaq 0x313cf3(%rip), %rax    # 0x4f03d0
movq %rax, 0xc4b62c(%rip)    # 0xe27d10
jmp 0x1dc6f4
leaq 0xbb0b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b61c(%rip)    # 0xe27d10
jmp 0x1dc6f6
jmp 0x1dc6f8
movq 0xc4b611(%rip), %rax    # 0xe27d10
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_diag_8_dispatcher
parasail_result_t* parasail_sw_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_rowcol_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_stats_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 0x1dc76e
leaq 0x9d9cbb(%rip), %rax    # 0xbb6420
movq %rax, 0xc4b5ac(%rip)    # 0xe27d18
jmp 0x1dc7b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc78a
leaq 0x60acef(%rip), %rax    # 0x7e7470
movq %rax, 0xc4b590(%rip)    # 0xe27d18
jmp 0x1dc7b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc7a6
leaq 0x323273(%rip), %rax    # 0x4ffa10
movq %rax, 0xc4b574(%rip)    # 0xe27d18
jmp 0x1dc7b4
leaq 0xbaff3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b564(%rip)    # 0xe27d18
jmp 0x1dc7b6
jmp 0x1dc7b8
movq 0xc4b559(%rip), %rax    # 0xe27d18
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_trace_scan_64_dispatcher
parasail_result_t* parasail_sw_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_64_pointer = parasail_sw_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x1dc82e
leaq 0xa1d4bb(%rip), %rax    # 0xbf9ce0
movq %rax, 0xc4b4f4(%rip)    # 0xe27d20
jmp 0x1dc878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc84a
leaq 0x63f79f(%rip), %rax    # 0x81bfe0
movq %rax, 0xc4b4d8(%rip)    # 0xe27d20
jmp 0x1dc876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc866
leaq 0x355ef3(%rip), %rax    # 0x532750
movq %rax, 0xc4b4bc(%rip)    # 0xe27d20
jmp 0x1dc874
leaq 0xbce93(%rip), %rax     # 0x299700
movq %rax, 0xc4b4ac(%rip)    # 0xe27d20
jmp 0x1dc876
jmp 0x1dc878
movq 0xc4b4a1(%rip), %rax    # 0xe27d20
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_trace_scan_32_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_scan_32_pointer = parasail_sw_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_32_pointer = parasail_sw_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x1dc8ee
leaq 0xa25afb(%rip), %rax    # 0xc023e0
movq %rax, 0xc4b43c(%rip)    # 0xe27d28
jmp 0x1dc938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc90a
leaq 0x64608f(%rip), %rax    # 0x822990
movq %rax, 0xc4b420(%rip)    # 0xe27d28
jmp 0x1dc936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc926
leaq 0x35c8d3(%rip), %rax    # 0x5391f0
movq %rax, 0xc4b404(%rip)    # 0xe27d28
jmp 0x1dc934
leaq 0xbcdd3(%rip), %rax     # 0x299700
movq %rax, 0xc4b3f4(%rip)    # 0xe27d28
jmp 0x1dc936
jmp 0x1dc938
movq 0xc4b3e9(%rip), %rax    # 0xe27d28
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_trace_scan_16_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_scan_16_pointer = parasail_sw_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_16_pointer = parasail_sw_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x1dc9ae
leaq 0xa2fbfb(%rip), %rax    # 0xc0c5a0
movq %rax, 0xc4b384(%rip)    # 0xe27d30
jmp 0x1dc9f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dc9ca
leaq 0x64d45f(%rip), %rax    # 0x829e20
movq %rax, 0xc4b368(%rip)    # 0xe27d30
jmp 0x1dc9f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dc9e6
leaq 0x363e53(%rip), %rax    # 0x540830
movq %rax, 0xc4b34c(%rip)    # 0xe27d30
jmp 0x1dc9f4
leaq 0xbcd13(%rip), %rax     # 0x299700
movq %rax, 0xc4b33c(%rip)    # 0xe27d30
jmp 0x1dc9f6
jmp 0x1dc9f8
movq 0xc4b331(%rip), %rax    # 0xe27d30
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_trace_scan_8_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_scan_8_pointer = parasail_sw_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_8_pointer = parasail_sw_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_trace_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_trace_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 0x1dca6e
leaq 0xa3cf4b(%rip), %rax    # 0xc199b0
movq %rax, 0xc4b2cc(%rip)    # 0xe27d38
jmp 0x1dcab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dca8a
leaq 0x655aff(%rip), %rax    # 0x832580
movq %rax, 0xc4b2b0(%rip)    # 0xe27d38
jmp 0x1dcab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dcaa6
leaq 0x36c943(%rip), %rax    # 0x5493e0
movq %rax, 0xc4b294(%rip)    # 0xe27d38
jmp 0x1dcab4
leaq 0xbcc53(%rip), %rax     # 0x299700
movq %rax, 0xc4b284(%rip)    # 0xe27d38
jmp 0x1dcab6
jmp 0x1dcab8
movq 0xc4b279(%rip), %rax    # 0xe27d38
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_trace_striped_64_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_64_pointer = parasail_sw_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_64_pointer = parasail_sw_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dcb2e
leaq 0xa866bb(%rip), %rax    # 0xc631e0
movq %rax, 0xc4b214(%rip)    # 0xe27d40
jmp 0x1dcb78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dcb4a
leaq 0x6844ef(%rip), %rax    # 0x861030
movq %rax, 0xc4b1f8(%rip)    # 0xe27d40
jmp 0x1dcb76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dcb66
leaq 0x39bd33(%rip), %rax    # 0x578890
movq %rax, 0xc4b1dc(%rip)    # 0xe27d40
jmp 0x1dcb74
leaq 0xbac33(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b1cc(%rip)    # 0xe27d40
jmp 0x1dcb76
jmp 0x1dcb78
movq 0xc4b1c1(%rip), %rax    # 0xe27d40
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_trace_striped_32_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_32_pointer = parasail_sw_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_32_pointer = parasail_sw_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dcbee
leaq 0xa904bb(%rip), %rax    # 0xc6d0a0
movq %rax, 0xc4b15c(%rip)    # 0xe27d48
jmp 0x1dcc38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dcc0a
leaq 0x68c46f(%rip), %rax    # 0x869070
movq %rax, 0xc4b140(%rip)    # 0xe27d48
jmp 0x1dcc36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dcc26
leaq 0x3a3c63(%rip), %rax    # 0x580880
movq %rax, 0xc4b124(%rip)    # 0xe27d48
jmp 0x1dcc34
leaq 0xbab73(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b114(%rip)    # 0xe27d48
jmp 0x1dcc36
jmp 0x1dcc38
movq 0xc4b109(%rip), %rax    # 0xe27d48
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_trace_striped_16_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_16_pointer = parasail_sw_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_16_pointer = parasail_sw_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dccae
leaq 0xa9bd2b(%rip), %rax    # 0xc789d0
movq %rax, 0xc4b0a4(%rip)    # 0xe27d50
jmp 0x1dccf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dccca
leaq 0x6950cf(%rip), %rax    # 0x871d90
movq %rax, 0xc4b088(%rip)    # 0xe27d50
jmp 0x1dccf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dcce6
leaq 0x3ac893(%rip), %rax    # 0x589570
movq %rax, 0xc4b06c(%rip)    # 0xe27d50
jmp 0x1dccf4
leaq 0xbaab3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4b05c(%rip)    # 0xe27d50
jmp 0x1dccf6
jmp 0x1dccf8
movq 0xc4b051(%rip), %rax    # 0xe27d50
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_trace_striped_8_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_striped_8_pointer = parasail_sw_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_8_pointer = parasail_sw_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_trace_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dcd6e
leaq 0xaaa4ab(%rip), %rax    # 0xc87210
movq %rax, 0xc4afec(%rip)    # 0xe27d58
jmp 0x1dcdb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dcd8a
leaq 0x69f1af(%rip), %rax    # 0x87bf30
movq %rax, 0xc4afd0(%rip)    # 0xe27d58
jmp 0x1dcdb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dcda6
leaq 0x3b6c33(%rip), %rax    # 0x5939d0
movq %rax, 0xc4afb4(%rip)    # 0xe27d58
jmp 0x1dcdb4
leaq 0xba9f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4afa4(%rip)    # 0xe27d58
jmp 0x1dcdb6
jmp 0x1dcdb8
movq 0xc4af99(%rip), %rax    # 0xe27d58
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_trace_diag_64_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_64_pointer = parasail_sw_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_64_pointer = parasail_sw_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_trace_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dce2e
leaq 0xa4795b(%rip), %rax    # 0xc24780
movq %rax, 0xc4af34(%rip)    # 0xe27d60
jmp 0x1dce78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dce4a
leaq 0x65cb3f(%rip), %rax    # 0x839980
movq %rax, 0xc4af18(%rip)    # 0xe27d60
jmp 0x1dce76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dce66
leaq 0x3739e3(%rip), %rax    # 0x550840
movq %rax, 0xc4aefc(%rip)    # 0xe27d60
jmp 0x1dce74
leaq 0xba933(%rip), %rax     # 0x2977a0
movq %rax, 0xc4aeec(%rip)    # 0xe27d60
jmp 0x1dce76
jmp 0x1dce78
movq 0xc4aee1(%rip), %rax    # 0xe27d60
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_trace_diag_32_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_32_pointer = parasail_sw_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_32_pointer = parasail_sw_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_trace_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dceee
leaq 0xa51e8b(%rip), %rax    # 0xc2ed70
movq %rax, 0xc4ae7c(%rip)    # 0xe27d68
jmp 0x1dcf38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dcf0a
leaq 0x663cbf(%rip), %rax    # 0x840bc0
movq %rax, 0xc4ae60(%rip)    # 0xe27d68
jmp 0x1dcf36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dcf26
leaq 0x37ab93(%rip), %rax    # 0x557ab0
movq %rax, 0xc4ae44(%rip)    # 0xe27d68
jmp 0x1dcf34
leaq 0xba873(%rip), %rax     # 0x2977a0
movq %rax, 0xc4ae34(%rip)    # 0xe27d68
jmp 0x1dcf36
jmp 0x1dcf38
movq 0xc4ae29(%rip), %rax    # 0xe27d68
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_trace_diag_16_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_16_pointer = parasail_sw_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_16_pointer = parasail_sw_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_trace_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dcfae
leaq 0xa607ab(%rip), %rax    # 0xc3d750
movq %rax, 0xc4adc4(%rip)    # 0xe27d70
jmp 0x1dcff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dcfca
leaq 0x66cdcf(%rip), %rax    # 0x849d90
movq %rax, 0xc4ada8(%rip)    # 0xe27d70
jmp 0x1dcff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dcfe6
leaq 0x383dc3(%rip), %rax    # 0x560da0
movq %rax, 0xc4ad8c(%rip)    # 0xe27d70
jmp 0x1dcff4
leaq 0xba7b3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4ad7c(%rip)    # 0xe27d70
jmp 0x1dcff6
jmp 0x1dcff8
movq 0xc4ad71(%rip), %rax    # 0xe27d70
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_trace_diag_8_dispatcher
parasail_result_t* parasail_sw_trace_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_trace_diag_8_pointer = parasail_sw_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_diag_8_pointer = parasail_sw_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_trace_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_trace_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 0x1dd06e
leaq 0xa772ab(%rip), %rax    # 0xc54310
movq %rax, 0xc4ad0c(%rip)    # 0xe27d78
jmp 0x1dd0b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd08a
leaq 0x679acf(%rip), %rax    # 0x856b50
movq %rax, 0xc4acf0(%rip)    # 0xe27d78
jmp 0x1dd0b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd0a6
leaq 0x391153(%rip), %rax    # 0x56e1f0
movq %rax, 0xc4acd4(%rip)    # 0xe27d78
jmp 0x1dd0b4
leaq 0xba6f3(%rip), %rax     # 0x2977a0
movq %rax, 0xc4acc4(%rip)    # 0xe27d78
jmp 0x1dd0b6
jmp 0x1dd0b8
movq 0xc4acb9(%rip), %rax    # 0xe27d78
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_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_64_pointer = parasail_sw_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd126
leaq 0x6a6a43(%rip), %rax    # 0x883b60
movq %rax, 0xc4ac5c(%rip)    # 0xe27d80
jmp 0x1dd16c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd142
leaq 0x3bdb17(%rip), %rax    # 0x59ac50
movq %rax, 0xc4ac40(%rip)    # 0xe27d80
jmp 0x1dd16a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd15e
leaq 0xe3bbb(%rip), %rax     # 0x2c0d10
movq %rax, 0xc4ac24(%rip)    # 0xe27d80
jmp 0x1dd168
movq $0x0, -0x8(%rbp)
jmp 0x1dd18b
jmp 0x1dd16a
jmp 0x1dd16c
movq 0xc4ac0d(%rip), %rax    # 0xe27d80
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_32_pointer = parasail_sw_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd1d6
leaq 0x6ace73(%rip), %rax    # 0x88a040
movq %rax, 0xc4abb4(%rip)    # 0xe27d88
jmp 0x1dd21c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd1f2
leaq 0x3c2ce7(%rip), %rax    # 0x59fed0
movq %rax, 0xc4ab98(%rip)    # 0xe27d88
jmp 0x1dd21a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd20e
leaq 0xe8f6b(%rip), %rax     # 0x2c6170
movq %rax, 0xc4ab7c(%rip)    # 0xe27d88
jmp 0x1dd218
movq $0x0, -0x8(%rbp)
jmp 0x1dd23b
jmp 0x1dd21a
jmp 0x1dd21c
movq 0xc4ab65(%rip), %rax    # 0xe27d88
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)