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_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_diag_8_pointer = parasail_sg_dx_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x20ecee
leaq 0x6b66ab(%rip), %rax    # 0x8c5390
movq %rax, 0xc1a88c(%rip)    # 0xe29578
jmp 0x20ed38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20ed0a
leaq 0x3b859f(%rip), %rax    # 0x5c72a0
movq %rax, 0xc1a870(%rip)    # 0xe29578
jmp 0x20ed36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20ed26
leaq 0xdf7d3(%rip), %rax     # 0x2ee4f0
movq %rax, 0xc1a854(%rip)    # 0xe29578
jmp 0x20ed34
leaq 0x887d3(%rip), %rax     # 0x297500
movq %rax, 0xc1a844(%rip)    # 0xe29578
jmp 0x20ed36
jmp 0x20ed38
movq 0xc1a839(%rip), %rax    # 0xe29578
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_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_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 0x20edae
leaq 0x6dd67b(%rip), %rax    # 0x8ec420
movq %rax, 0xc1a7d4(%rip)    # 0xe29580
jmp 0x20edf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20edca
leaq 0x3d85ff(%rip), %rax    # 0x5e73c0
movq %rax, 0xc1a7b8(%rip)    # 0xe29580
jmp 0x20edf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20ede6
leaq 0xfe143(%rip), %rax     # 0x30cf20
movq %rax, 0xc1a79c(%rip)    # 0xe29580
jmp 0x20edf4
leaq 0x8a673(%rip), %rax     # 0x299460
movq %rax, 0xc1a78c(%rip)    # 0xe29580
jmp 0x20edf6
jmp 0x20edf8
movq 0xc1a781(%rip), %rax    # 0xe29580
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_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_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 0x20ee6e
leaq 0x6ea86b(%rip), %rax    # 0x8f96d0
movq %rax, 0xc1a71c(%rip)    # 0xe29588
jmp 0x20eeb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20ee8a
leaq 0x3e2f8f(%rip), %rax    # 0x5f1e10
movq %rax, 0xc1a700(%rip)    # 0xe29588
jmp 0x20eeb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20eea6
leaq 0x107d73(%rip), %rax    # 0x316c10
movq %rax, 0xc1a6e4(%rip)    # 0xe29588
jmp 0x20eeb4
leaq 0x8a5b3(%rip), %rax     # 0x299460
movq %rax, 0xc1a6d4(%rip)    # 0xe29588
jmp 0x20eeb6
jmp 0x20eeb8
movq 0xc1a6c9(%rip), %rax    # 0xe29588
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_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_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 0x20ef2e
leaq 0x6f901b(%rip), %rax    # 0x907f40
movq %rax, 0xc1a664(%rip)    # 0xe29590
jmp 0x20ef78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20ef4a
leaq 0x3edfff(%rip), %rax    # 0x5fcf40
movq %rax, 0xc1a648(%rip)    # 0xe29590
jmp 0x20ef76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20ef66
leaq 0x112013(%rip), %rax    # 0x320f70
movq %rax, 0xc1a62c(%rip)    # 0xe29590
jmp 0x20ef74
leaq 0x8a4f3(%rip), %rax     # 0x299460
movq %rax, 0xc1a61c(%rip)    # 0xe29590
jmp 0x20ef76
jmp 0x20ef78
movq 0xc1a611(%rip), %rax    # 0xe29590
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_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_stats_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 0x20efee
leaq 0x709f4b(%rip), %rax    # 0x918f30
movq %rax, 0xc1a5ac(%rip)    # 0xe29598
jmp 0x20f038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f00a
leaq 0x3f9b2f(%rip), %rax    # 0x608b30
movq %rax, 0xc1a590(%rip)    # 0xe29598
jmp 0x20f036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f026
leaq 0x11cf83(%rip), %rax    # 0x32bfa0
movq %rax, 0xc1a574(%rip)    # 0xe29598
jmp 0x20f034
leaq 0x8a433(%rip), %rax     # 0x299460
movq %rax, 0xc1a564(%rip)    # 0xe29598
jmp 0x20f036
jmp 0x20f038
movq 0xc1a559(%rip), %rax    # 0xe29598
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_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f0ae
leaq 0x75abbb(%rip), %rax    # 0x969c60
movq %rax, 0xc1a4f4(%rip)    # 0xe295a0
jmp 0x20f0f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f0ca
leaq 0x431caf(%rip), %rax    # 0x640d70
movq %rax, 0xc1a4d8(%rip)    # 0xe295a0
jmp 0x20f0f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f0e6
leaq 0x153373(%rip), %rax    # 0x362450
movq %rax, 0xc1a4bc(%rip)    # 0xe295a0
jmp 0x20f0f4
leaq 0x88413(%rip), %rax     # 0x297500
movq %rax, 0xc1a4ac(%rip)    # 0xe295a0
jmp 0x20f0f6
jmp 0x20f0f8
movq 0xc1a4a1(%rip), %rax    # 0xe295a0
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_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f16e
leaq 0x765abb(%rip), %rax    # 0x974c20
movq %rax, 0xc1a43c(%rip)    # 0xe295a8
jmp 0x20f1b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f18a
leaq 0x43b08f(%rip), %rax    # 0x64a210
movq %rax, 0xc1a420(%rip)    # 0xe295a8
jmp 0x20f1b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f1a6
leaq 0x15c053(%rip), %rax    # 0x36b1f0
movq %rax, 0xc1a404(%rip)    # 0xe295a8
jmp 0x20f1b4
leaq 0x88353(%rip), %rax     # 0x297500
movq %rax, 0xc1a3f4(%rip)    # 0xe295a8
jmp 0x20f1b6
jmp 0x20f1b8
movq 0xc1a3e9(%rip), %rax    # 0xe295a8
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_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f22e
leaq 0x77163b(%rip), %rax    # 0x980860
movq %rax, 0xc1a384(%rip)    # 0xe295b0
jmp 0x20f278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f24a
leaq 0x444a3f(%rip), %rax    # 0x653c80
movq %rax, 0xc1a368(%rip)    # 0xe295b0
jmp 0x20f276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f266
leaq 0x165193(%rip), %rax    # 0x3743f0
movq %rax, 0xc1a34c(%rip)    # 0xe295b0
jmp 0x20f274
leaq 0x88293(%rip), %rax     # 0x297500
movq %rax, 0xc1a33c(%rip)    # 0xe295b0
jmp 0x20f276
jmp 0x20f278
movq 0xc1a331(%rip), %rax    # 0xe295b0
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_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f2ee
leaq 0x77ea8b(%rip), %rax    # 0x98dd70
movq %rax, 0xc1a2cc(%rip)    # 0xe295b8
jmp 0x20f338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f30a
leaq 0x44f08f(%rip), %rax    # 0x65e390
movq %rax, 0xc1a2b0(%rip)    # 0xe295b8
jmp 0x20f336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f326
leaq 0x16efb3(%rip), %rax    # 0x37e2d0
movq %rax, 0xc1a294(%rip)    # 0xe295b8
jmp 0x20f334
leaq 0x881d3(%rip), %rax     # 0x297500
movq %rax, 0xc1a284(%rip)    # 0xe295b8
jmp 0x20f336
jmp 0x20f338
movq 0xc1a279(%rip), %rax    # 0xe295b8
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_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f3ae
leaq 0x717feb(%rip), %rax    # 0x927390
movq %rax, 0xc1a214(%rip)    # 0xe295c0
jmp 0x20f3f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f3ca
leaq 0x403caf(%rip), %rax    # 0x613070
movq %rax, 0xc1a1f8(%rip)    # 0xe295c0
jmp 0x20f3f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f3e6
leaq 0x126803(%rip), %rax    # 0x335be0
movq %rax, 0xc1a1dc(%rip)    # 0xe295c0
jmp 0x20f3f4
leaq 0x88113(%rip), %rax     # 0x297500
movq %rax, 0xc1a1cc(%rip)    # 0xe295c0
jmp 0x20f3f6
jmp 0x20f3f8
movq 0xc1a1c1(%rip), %rax    # 0xe295c0
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_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_diag_32_pointer = parasail_sg_dx_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f46e
leaq 0x72502b(%rip), %rax    # 0x934490
movq %rax, 0xc1a15c(%rip)    # 0xe295c8
jmp 0x20f4b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f48a
leaq 0x40d68f(%rip), %rax    # 0x61cb10
movq %rax, 0xc1a140(%rip)    # 0xe295c8
jmp 0x20f4b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f4a6
leaq 0x12fbe3(%rip), %rax    # 0x33f080
movq %rax, 0xc1a124(%rip)    # 0xe295c8
jmp 0x20f4b4
leaq 0x88053(%rip), %rax     # 0x297500
movq %rax, 0xc1a114(%rip)    # 0xe295c8
jmp 0x20f4b6
jmp 0x20f4b8
movq 0xc1a109(%rip), %rax    # 0xe295c8
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_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_diag_16_pointer = parasail_sg_dx_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f52e
leaq 0x73534b(%rip), %rax    # 0x944870
movq %rax, 0xc1a0a4(%rip)    # 0xe295d0
jmp 0x20f578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f54a
leaq 0x41882f(%rip), %rax    # 0x627d70
movq %rax, 0xc1a088(%rip)    # 0xe295d0
jmp 0x20f576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f566
leaq 0x13a6d3(%rip), %rax    # 0x349c30
movq %rax, 0xc1a06c(%rip)    # 0xe295d0
jmp 0x20f574
leaq 0x87f93(%rip), %rax     # 0x297500
movq %rax, 0xc1a05c(%rip)    # 0xe295d0
jmp 0x20f576
jmp 0x20f578
movq 0xc1a051(%rip), %rax    # 0xe295d0
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_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_diag_8_pointer = parasail_sg_dx_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x20f5ee
leaq 0x74b62b(%rip), %rax    # 0x95ac10
movq %rax, 0xc19fec(%rip)    # 0xe295d8
jmp 0x20f638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f60a
leaq 0x42655f(%rip), %rax    # 0x635b60
movq %rax, 0xc19fd0(%rip)    # 0xe295d8
jmp 0x20f636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f626
leaq 0x148203(%rip), %rax    # 0x357820
movq %rax, 0xc19fb4(%rip)    # 0xe295d8
jmp 0x20f634
leaq 0x87ed3(%rip), %rax     # 0x297500
movq %rax, 0xc19fa4(%rip)    # 0xe295d8
jmp 0x20f636
jmp 0x20f638
movq 0xc19f99(%rip), %rax    # 0xe295d8
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_table_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_table_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_table_scan_64_pointer = parasail_sg_dx_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_table_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 0x20f6ae
leaq 0x78a49b(%rip), %rax    # 0x999b40
movq %rax, 0xc19f34(%rip)    # 0xe295e0
jmp 0x20f6f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f6ca
leaq 0x4563df(%rip), %rax    # 0x665aa0
movq %rax, 0xc19f18(%rip)    # 0xe295e0
jmp 0x20f6f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f6e6
leaq 0x1783f3(%rip), %rax    # 0x387ad0
movq %rax, 0xc19efc(%rip)    # 0xe295e0
jmp 0x20f6f4
leaq 0x89d73(%rip), %rax     # 0x299460
movq %rax, 0xc19eec(%rip)    # 0xe295e0
jmp 0x20f6f6
jmp 0x20f6f8
movq 0xc19ee1(%rip), %rax    # 0xe295e0
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_table_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_table_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_table_scan_32_pointer = parasail_sg_dx_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_table_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 0x20f76e
leaq 0x790dfb(%rip), %rax    # 0x9a0560
movq %rax, 0xc19e7c(%rip)    # 0xe295e8
jmp 0x20f7b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f78a
leaq 0x45b86f(%rip), %rax    # 0x66aff0
movq %rax, 0xc19e60(%rip)    # 0xe295e8
jmp 0x20f7b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f7a6
leaq 0x17db23(%rip), %rax    # 0x38d2c0
movq %rax, 0xc19e44(%rip)    # 0xe295e8
jmp 0x20f7b4
leaq 0x89cb3(%rip), %rax     # 0x299460
movq %rax, 0xc19e34(%rip)    # 0xe295e8
jmp 0x20f7b6
jmp 0x20f7b8
movq 0xc19e29(%rip), %rax    # 0xe295e8
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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_table_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_table_scan_16_pointer = parasail_sg_dx_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_table_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 0x20f82e
leaq 0x798abb(%rip), %rax    # 0x9a82e0
movq %rax, 0xc19dc4(%rip)    # 0xe295f0
jmp 0x20f878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f84a
leaq 0x46141f(%rip), %rax    # 0x670c60
movq %rax, 0xc19da8(%rip)    # 0xe295f0
jmp 0x20f876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f866
leaq 0x183863(%rip), %rax    # 0x3930c0
movq %rax, 0xc19d8c(%rip)    # 0xe295f0
jmp 0x20f874
leaq 0x89bf3(%rip), %rax     # 0x299460
movq %rax, 0xc19d7c(%rip)    # 0xe295f0
jmp 0x20f876
jmp 0x20f878
movq 0xc19d71(%rip), %rax    # 0xe295f0
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_table_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_table_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_table_scan_8_pointer = parasail_sg_dx_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_table_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_table_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 0x20f8ee
leaq 0x7a2c2b(%rip), %rax    # 0x9b2510
movq %rax, 0xc19d0c(%rip)    # 0xe295f8
jmp 0x20f938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f90a
leaq 0x467c2f(%rip), %rax    # 0x677530
movq %rax, 0xc19cf0(%rip)    # 0xe295f8
jmp 0x20f936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f926
leaq 0x18a3f3(%rip), %rax    # 0x399d10
movq %rax, 0xc19cd4(%rip)    # 0xe295f8
jmp 0x20f934
leaq 0x89b33(%rip), %rax     # 0x299460
movq %rax, 0xc19cc4(%rip)    # 0xe295f8
jmp 0x20f936
jmp 0x20f938
movq 0xc19cb9(%rip), %rax    # 0xe295f8
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_table_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_table_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_table_striped_64_pointer = parasail_sg_dx_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_table_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_table_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 0x20f9ae
leaq 0x7ddceb(%rip), %rax    # 0x9ed690
movq %rax, 0xc19c54(%rip)    # 0xe29600
jmp 0x20f9f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20f9ca
leaq 0x48d9ff(%rip), %rax    # 0x69d3c0
movq %rax, 0xc19c38(%rip)    # 0xe29600
jmp 0x20f9f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20f9e6
leaq 0x1b11d3(%rip), %rax    # 0x3c0bb0
movq %rax, 0xc19c1c(%rip)    # 0xe29600
jmp 0x20f9f4
leaq 0x87b13(%rip), %rax     # 0x297500
movq %rax, 0xc19c0c(%rip)    # 0xe29600
jmp 0x20f9f6
jmp 0x20f9f8
movq 0xc19c01(%rip), %rax    # 0xe29600
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_table_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_table_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_table_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 0x20fa6e
leaq 0x7e383b(%rip), %rax    # 0x9f32a0
movq %rax, 0xc19b9c(%rip)    # 0xe29608
jmp 0x20fab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20fa8a
leaq 0x4926ff(%rip), %rax    # 0x6a2180
movq %rax, 0xc19b80(%rip)    # 0xe29608
jmp 0x20fab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20faa6
leaq 0x1b6113(%rip), %rax    # 0x3c5bb0
movq %rax, 0xc19b64(%rip)    # 0xe29608
jmp 0x20fab4
leaq 0x87a53(%rip), %rax     # 0x297500
movq %rax, 0xc19b54(%rip)    # 0xe29608
jmp 0x20fab6
jmp 0x20fab8
movq 0xc19b49(%rip), %rax    # 0xe29608
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_table_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_table_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_table_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 0x20fb2e
leaq 0x7ea1eb(%rip), %rax    # 0x9f9d10
movq %rax, 0xc19ae4(%rip)    # 0xe29610
jmp 0x20fb78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20fb4a
leaq 0x497a0f(%rip), %rax    # 0x6a7550
movq %rax, 0xc19ac8(%rip)    # 0xe29610
jmp 0x20fb76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x20fb66
leaq 0x1bb533(%rip), %rax    # 0x3cb090
movq %rax, 0xc19aac(%rip)    # 0xe29610
jmp 0x20fb74
leaq 0x87993(%rip), %rax     # 0x297500
movq %rax, 0xc19a9c(%rip)    # 0xe29610
jmp 0x20fb76
jmp 0x20fb78
movq 0xc19a91(%rip), %rax    # 0xe29610
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)