LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x21186e
leaq 0x978fdb(%rip), %rax    # 0xb8a840
movq %rax, 0xc17edc(%rip)    # 0xe29748
jmp 0x2118b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x21188a
leaq 0x5ba11f(%rip), %rax    # 0x7cb9a0
movq %rax, 0xc17ec0(%rip)    # 0xe29748
jmp 0x2118b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2118a6
leaq 0x2d2e43(%rip), %rax    # 0x4e46e0
movq %rax, 0xc17ea4(%rip)    # 0xe29748
jmp 0x2118b4
leaq 0x85c53(%rip), %rax     # 0x297500
movq %rax, 0xc17e94(%rip)    # 0xe29748
jmp 0x2118b6
jmp 0x2118b8
movq 0xc17e89(%rip), %rax    # 0xe29748
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x21192e
leaq 0x98aeeb(%rip), %rax    # 0xb9c810
movq %rax, 0xc17e24(%rip)    # 0xe29750
jmp 0x211978
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x21194a
leaq 0x5c60ef(%rip), %rax    # 0x7d7a30
movq %rax, 0xc17e08(%rip)    # 0xe29750
jmp 0x211976
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211966
leaq 0x2de7d3(%rip), %rax    # 0x4f0130
movq %rax, 0xc17dec(%rip)    # 0xe29750
jmp 0x211974
leaq 0x85b93(%rip), %rax     # 0x297500
movq %rax, 0xc17ddc(%rip)    # 0xe29750
jmp 0x211976
jmp 0x211978
movq 0xc17dd1(%rip), %rax    # 0xe29750
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
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 0x2119ee
leaq 0x9a479b(%rip), %rax    # 0xbb6180
movq %rax, 0xc17d6c(%rip)    # 0xe29758
jmp 0x211a38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211a0a
leaq 0x5d57cf(%rip), %rax    # 0x7e71d0
movq %rax, 0xc17d50(%rip)    # 0xe29758
jmp 0x211a36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211a26
leaq 0x2edd53(%rip), %rax    # 0x4ff770
movq %rax, 0xc17d34(%rip)    # 0xe29758
jmp 0x211a34
leaq 0x85ad3(%rip), %rax     # 0x297500
movq %rax, 0xc17d24(%rip)    # 0xe29758
jmp 0x211a36
jmp 0x211a38
movq 0xc17d19(%rip), %rax    # 0xe29758
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x211aae
leaq 0x9e7b7b(%rip), %rax    # 0xbf9620
movq %rax, 0xc17cb4(%rip)    # 0xe29760
jmp 0x211af8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211aca
leaq 0x609e5f(%rip), %rax    # 0x81b920
movq %rax, 0xc17c98(%rip)    # 0xe29760
jmp 0x211af6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211ae6
leaq 0x3205b3(%rip), %rax    # 0x532090
movq %rax, 0xc17c7c(%rip)    # 0xe29760
jmp 0x211af4
leaq 0x87973(%rip), %rax     # 0x299460
movq %rax, 0xc17c6c(%rip)    # 0xe29760
jmp 0x211af6
jmp 0x211af8
movq 0xc17c61(%rip), %rax    # 0xe29760
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x211b6e
leaq 0x9f01bb(%rip), %rax    # 0xc01d20
movq %rax, 0xc17bfc(%rip)    # 0xe29768
jmp 0x211bb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211b8a
leaq 0x61074f(%rip), %rax    # 0x8222d0
movq %rax, 0xc17be0(%rip)    # 0xe29768
jmp 0x211bb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211ba6
leaq 0x326f93(%rip), %rax    # 0x538b30
movq %rax, 0xc17bc4(%rip)    # 0xe29768
jmp 0x211bb4
leaq 0x878b3(%rip), %rax     # 0x299460
movq %rax, 0xc17bb4(%rip)    # 0xe29768
jmp 0x211bb6
jmp 0x211bb8
movq 0xc17ba9(%rip), %rax    # 0xe29768
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x211c2e
leaq 0x9fa2bb(%rip), %rax    # 0xc0bee0
movq %rax, 0xc17b44(%rip)    # 0xe29770
jmp 0x211c78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211c4a
leaq 0x617b1f(%rip), %rax    # 0x829760
movq %rax, 0xc17b28(%rip)    # 0xe29770
jmp 0x211c76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211c66
leaq 0x32e513(%rip), %rax    # 0x540170
movq %rax, 0xc17b0c(%rip)    # 0xe29770
jmp 0x211c74
leaq 0x877f3(%rip), %rax     # 0x299460
movq %rax, 0xc17afc(%rip)    # 0xe29770
jmp 0x211c76
jmp 0x211c78
movq 0xc17af1(%rip), %rax    # 0xe29770
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x211cee
leaq 0xa0760b(%rip), %rax    # 0xc192f0
movq %rax, 0xc17a8c(%rip)    # 0xe29778
jmp 0x211d38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211d0a
leaq 0x6201bf(%rip), %rax    # 0x831ec0
movq %rax, 0xc17a70(%rip)    # 0xe29778
jmp 0x211d36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211d26
leaq 0x337003(%rip), %rax    # 0x548d20
movq %rax, 0xc17a54(%rip)    # 0xe29778
jmp 0x211d34
leaq 0x87733(%rip), %rax     # 0x299460
movq %rax, 0xc17a44(%rip)    # 0xe29778
jmp 0x211d36
jmp 0x211d38
movq 0xc17a39(%rip), %rax    # 0xe29778
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x211dae
leaq 0xa50d7b(%rip), %rax    # 0xc62b20
movq %rax, 0xc179d4(%rip)    # 0xe29780
jmp 0x211df8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211dca
leaq 0x64ebaf(%rip), %rax    # 0x860970
movq %rax, 0xc179b8(%rip)    # 0xe29780
jmp 0x211df6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211de6
leaq 0x3663f3(%rip), %rax    # 0x5781d0
movq %rax, 0xc1799c(%rip)    # 0xe29780
jmp 0x211df4
leaq 0x85713(%rip), %rax     # 0x297500
movq %rax, 0xc1798c(%rip)    # 0xe29780
jmp 0x211df6
jmp 0x211df8
movq 0xc17981(%rip), %rax    # 0xe29780
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x211e6e
leaq 0xa5ab7b(%rip), %rax    # 0xc6c9e0
movq %rax, 0xc1791c(%rip)    # 0xe29788
jmp 0x211eb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211e8a
leaq 0x656b2f(%rip), %rax    # 0x8689b0
movq %rax, 0xc17900(%rip)    # 0xe29788
jmp 0x211eb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211ea6
leaq 0x36e323(%rip), %rax    # 0x5801c0
movq %rax, 0xc178e4(%rip)    # 0xe29788
jmp 0x211eb4
leaq 0x85653(%rip), %rax     # 0x297500
movq %rax, 0xc178d4(%rip)    # 0xe29788
jmp 0x211eb6
jmp 0x211eb8
movq 0xc178c9(%rip), %rax    # 0xe29788
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x211f2e
leaq 0xa663eb(%rip), %rax    # 0xc78310
movq %rax, 0xc17864(%rip)    # 0xe29790
jmp 0x211f78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x211f4a
leaq 0x65f78f(%rip), %rax    # 0x8716d0
movq %rax, 0xc17848(%rip)    # 0xe29790
jmp 0x211f76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x211f66
leaq 0x376f53(%rip), %rax    # 0x588eb0
movq %rax, 0xc1782c(%rip)    # 0xe29790
jmp 0x211f74
leaq 0x85593(%rip), %rax     # 0x297500
movq %rax, 0xc1781c(%rip)    # 0xe29790
jmp 0x211f76
jmp 0x211f78
movq 0xc17811(%rip), %rax    # 0xe29790
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x211fee
leaq 0xa74b6b(%rip), %rax    # 0xc86b50
movq %rax, 0xc177ac(%rip)    # 0xe29798
jmp 0x212038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x21200a
leaq 0x66986f(%rip), %rax    # 0x87b870
movq %rax, 0xc17790(%rip)    # 0xe29798
jmp 0x212036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x212026
leaq 0x3812f3(%rip), %rax    # 0x593310
movq %rax, 0xc17774(%rip)    # 0xe29798
jmp 0x212034
leaq 0x854d3(%rip), %rax     # 0x297500
movq %rax, 0xc17764(%rip)    # 0xe29798
jmp 0x212036
jmp 0x212038
movq 0xc17759(%rip), %rax    # 0xe29798
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x2120ae
leaq 0xa1243b(%rip), %rax    # 0xc244e0
movq %rax, 0xc176f4(%rip)    # 0xe297a0
jmp 0x2120f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2120ca
leaq 0x62761f(%rip), %rax    # 0x8396e0
movq %rax, 0xc176d8(%rip)    # 0xe297a0
jmp 0x2120f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2120e6
leaq 0x33e4c3(%rip), %rax    # 0x5505a0
movq %rax, 0xc176bc(%rip)    # 0xe297a0
jmp 0x2120f4
leaq 0x85413(%rip), %rax     # 0x297500
movq %rax, 0xc176ac(%rip)    # 0xe297a0
jmp 0x2120f6
jmp 0x2120f8
movq 0xc176a1(%rip), %rax    # 0xe297a0
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x21216e
leaq 0xa1c96b(%rip), %rax    # 0xc2ead0
movq %rax, 0xc1763c(%rip)    # 0xe297a8
jmp 0x2121b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x21218a
leaq 0x62e79f(%rip), %rax    # 0x840920
movq %rax, 0xc17620(%rip)    # 0xe297a8
jmp 0x2121b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2121a6
leaq 0x345673(%rip), %rax    # 0x557810
movq %rax, 0xc17604(%rip)    # 0xe297a8
jmp 0x2121b4
leaq 0x85353(%rip), %rax     # 0x297500
movq %rax, 0xc175f4(%rip)    # 0xe297a8
jmp 0x2121b6
jmp 0x2121b8
movq 0xc175e9(%rip), %rax    # 0xe297a8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x21222e
leaq 0xa2b28b(%rip), %rax    # 0xc3d4b0
movq %rax, 0xc17584(%rip)    # 0xe297b0
jmp 0x212278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x21224a
leaq 0x6378af(%rip), %rax    # 0x849af0
movq %rax, 0xc17568(%rip)    # 0xe297b0
jmp 0x212276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x212266
leaq 0x34e8a3(%rip), %rax    # 0x560b00
movq %rax, 0xc1754c(%rip)    # 0xe297b0
jmp 0x212274
leaq 0x85293(%rip), %rax     # 0x297500
movq %rax, 0xc1753c(%rip)    # 0xe297b0
jmp 0x212276
jmp 0x212278
movq 0xc17531(%rip), %rax    # 0xe297b0
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_trace_diag_8_pointer = parasail_sg_dx_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_diag_8_pointer = parasail_sg_dx_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_diag_8_pointer = parasail_sg_dx_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_diag_8_pointer = parasail_sg_dx_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_diag_8_pointer = parasail_sg_dx_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_trace_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x2122ee
leaq 0xa41d8b(%rip), %rax    # 0xc54070
movq %rax, 0xc174cc(%rip)    # 0xe297b8
jmp 0x212338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x21230a
leaq 0x6445af(%rip), %rax    # 0x8568b0
movq %rax, 0xc174b0(%rip)    # 0xe297b8
jmp 0x212336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x212326
leaq 0x35bc33(%rip), %rax    # 0x56df50
movq %rax, 0xc17494(%rip)    # 0xe297b8
jmp 0x212334
leaq 0x851d3(%rip), %rax     # 0x297500
movq %rax, 0xc17484(%rip)    # 0xe297b8
jmp 0x212336
jmp 0x212338
movq 0xc17479(%rip), %rax    # 0xe297b8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_scan_profile_64_pointer = parasail_sg_dx_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_profile_64_pointer = parasail_sg_dx_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_profile_64_pointer = parasail_sg_dx_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_profile_64_pointer = parasail_sg_dx_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_profile_64_pointer = parasail_sg_dx_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x2123a6
leaq 0x671333(%rip), %rax    # 0x8836d0
movq %rax, 0xc1741c(%rip)    # 0xe297c0
jmp 0x2123ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2123c2
leaq 0x388407(%rip), %rax    # 0x59a7c0
movq %rax, 0xc17400(%rip)    # 0xe297c0
jmp 0x2123ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2123de
leaq 0xae4ab(%rip), %rax     # 0x2c0880
movq %rax, 0xc173e4(%rip)    # 0xe297c0
jmp 0x2123e8
movq $0x0, -0x8(%rbp)
jmp 0x21240b
jmp 0x2123ea
jmp 0x2123ec
movq 0xc173cd(%rip), %rax    # 0xe297c0
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_profile_32_pointer = parasail_sg_dx_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_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 0x212456
leaq 0x677763(%rip), %rax    # 0x889bb0
movq %rax, 0xc17374(%rip)    # 0xe297c8
jmp 0x21249c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x212472
leaq 0x38d5d7(%rip), %rax    # 0x59fa40
movq %rax, 0xc17358(%rip)    # 0xe297c8
jmp 0x21249a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x21248e
leaq 0xb385b(%rip), %rax     # 0x2c5ce0
movq %rax, 0xc1733c(%rip)    # 0xe297c8
jmp 0x212498
movq $0x0, -0x8(%rbp)
jmp 0x2124bb
jmp 0x21249a
jmp 0x21249c
movq 0xc17325(%rip), %rax    # 0xe297c8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_dx_scan_profile_16_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_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_profile_16_pointer = parasail_sg_dx_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_scan_profile_16_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 0x212506
leaq 0x67e9f3(%rip), %rax    # 0x890ef0
movq %rax, 0xc172cc(%rip)    # 0xe297d0
jmp 0x21254c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x212522
leaq 0x392ca7(%rip), %rax    # 0x5a51c0
movq %rax, 0xc172b0(%rip)    # 0xe297d0
jmp 0x21254a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x21253e
leaq 0xb906b(%rip), %rax     # 0x2cb5a0
movq %rax, 0xc17294(%rip)    # 0xe297d0
jmp 0x212548
movq $0x0, -0x8(%rbp)
jmp 0x21256b
jmp 0x21254a
jmp 0x21254c
movq 0xc1727d(%rip), %rax    # 0xe297d0
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_dx_scan_profile_8_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_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_profile_8_pointer = parasail_sg_dx_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_scan_profile_8_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 0x2125b6
leaq 0x687713(%rip), %rax    # 0x899cc0
movq %rax, 0xc17224(%rip)    # 0xe297d8
jmp 0x2125fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2125d2
leaq 0x398b67(%rip), %rax    # 0x5ab130
movq %rax, 0xc17208(%rip)    # 0xe297d8
jmp 0x2125fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2125ee
leaq 0xbf24b(%rip), %rax     # 0x2d1830
movq %rax, 0xc171ec(%rip)    # 0xe297d8
jmp 0x2125f8
movq $0x0, -0x8(%rbp)
jmp 0x21261b
jmp 0x2125fa
jmp 0x2125fc
movq 0xc171d5(%rip), %rax    # 0xe297d8
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/sg_dx_dispatch.c
// Function: parasail_sg_dx_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_dx_striped_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_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_profile_64_pointer = parasail_sg_dx_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_dx_striped_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 0x212666
leaq 0x6bc863(%rip), %rax    # 0x8ceec0
movq %rax, 0xc1717c(%rip)    # 0xe297e0
jmp 0x2126ac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x212682
leaq 0x3bbb87(%rip), %rax    # 0x5ce200
movq %rax, 0xc17160(%rip)    # 0xe297e0
jmp 0x2126aa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x21269e
leaq 0xe307b(%rip), %rax     # 0x2f5710
movq %rax, 0xc17144(%rip)    # 0xe297e0
jmp 0x2126a8
movq $0x0, -0x8(%rbp)
jmp 0x2126cb
jmp 0x2126aa
jmp 0x2126ac
movq 0xc1712d(%rip), %rax    # 0xe297e0
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)