LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d26ee
leaq 0x899dfb(%rip), %rax    # 0xa6c4e0
movq %rax, 0xc55104(%rip)    # 0xe277f0
jmp 0x1d2738
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d270a
leaq 0x529d2f(%rip), %rax    # 0x6fc430
movq %rax, 0xc550e8(%rip)    # 0xe277f0
jmp 0x1d2736
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2726
leaq 0x248033(%rip), %rax    # 0x41a750
movq %rax, 0xc550cc(%rip)    # 0xe277f0
jmp 0x1d2734
leaq 0xc5003(%rip), %rax     # 0x297730
movq %rax, 0xc550bc(%rip)    # 0xe277f0
jmp 0x1d2736
jmp 0x1d2738
movq 0xc550b1(%rip), %rax    # 0xe277f0
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_dispatch.c
// Function: parasail_sg_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d27ae
leaq 0x8b282b(%rip), %rax    # 0xa84fd0
movq %rax, 0xc5504c(%rip)    # 0xe277f8
jmp 0x1d27f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d27ca
leaq 0x538d8f(%rip), %rax    # 0x70b550
movq %rax, 0xc55030(%rip)    # 0xe277f8
jmp 0x1d27f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d27e6
leaq 0x256f03(%rip), %rax    # 0x4296e0
movq %rax, 0xc55014(%rip)    # 0xe277f8
jmp 0x1d27f4
leaq 0xc4f43(%rip), %rax     # 0x297730
movq %rax, 0xc55004(%rip)    # 0xe277f8
jmp 0x1d27f6
jmp 0x1d27f8
movq 0xc54ff9(%rip), %rax    # 0xe277f8
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_dispatch.c
// Function: parasail_sg_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d286e
leaq 0x8f3deb(%rip), %rax    # 0xac6650
movq %rax, 0xc54f94(%rip)    # 0xe27800
jmp 0x1d28b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d288a
leaq 0x56ba4f(%rip), %rax    # 0x73e2d0
movq %rax, 0xc54f78(%rip)    # 0xe27800
jmp 0x1d28b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d28a6
leaq 0x287d23(%rip), %rax    # 0x45a5c0
movq %rax, 0xc54f5c(%rip)    # 0xe27800
jmp 0x1d28b4
leaq 0xc6de3(%rip), %rax     # 0x299690
movq %rax, 0xc54f4c(%rip)    # 0xe27800
jmp 0x1d28b6
jmp 0x1d28b8
movq 0xc54f41(%rip), %rax    # 0xe27800
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_dispatch.c
// Function: parasail_sg_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d292e
leaq 0x8fa8fb(%rip), %rax    # 0xacd220
movq %rax, 0xc54edc(%rip)    # 0xe27808
jmp 0x1d2978
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d294a
leaq 0x5710df(%rip), %rax    # 0x743a20
movq %rax, 0xc54ec0(%rip)    # 0xe27808
jmp 0x1d2976
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2966
leaq 0x28d653(%rip), %rax    # 0x45ffb0
movq %rax, 0xc54ea4(%rip)    # 0xe27808
jmp 0x1d2974
leaq 0xc6d23(%rip), %rax     # 0x299690
movq %rax, 0xc54e94(%rip)    # 0xe27808
jmp 0x1d2976
jmp 0x1d2978
movq 0xc54e89(%rip), %rax    # 0xe27808
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_dispatch.c
// Function: parasail_sg_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d29ee
leaq 0x90262b(%rip), %rax    # 0xad5010
movq %rax, 0xc54e24(%rip)    # 0xe27810
jmp 0x1d2a38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2a0a
leaq 0x576e0f(%rip), %rax    # 0x749810
movq %rax, 0xc54e08(%rip)    # 0xe27810
jmp 0x1d2a36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2a26
leaq 0x293503(%rip), %rax    # 0x465f20
movq %rax, 0xc54dec(%rip)    # 0xe27810
jmp 0x1d2a34
leaq 0xc6c63(%rip), %rax     # 0x299690
movq %rax, 0xc54ddc(%rip)    # 0xe27810
jmp 0x1d2a36
jmp 0x1d2a38
movq 0xc54dd1(%rip), %rax    # 0xe27810
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_dispatch.c
// Function: parasail_sg_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d2aae
leaq 0x90c55b(%rip), %rax    # 0xadf000
movq %rax, 0xc54d6c(%rip)    # 0xe27818
jmp 0x1d2af8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2aca
leaq 0x57d66f(%rip), %rax    # 0x750130
movq %rax, 0xc54d50(%rip)    # 0xe27818
jmp 0x1d2af6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2ae6
leaq 0x29a083(%rip), %rax    # 0x46cb60
movq %rax, 0xc54d34(%rip)    # 0xe27818
jmp 0x1d2af4
leaq 0xc6ba3(%rip), %rax     # 0x299690
movq %rax, 0xc54d24(%rip)    # 0xe27818
jmp 0x1d2af6
jmp 0x1d2af8
movq 0xc54d19(%rip), %rax    # 0xe27818
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_dispatch.c
// Function: parasail_sg_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d2b6e
leaq 0x9494bb(%rip), %rax    # 0xb1c020
movq %rax, 0xc54cb4(%rip)    # 0xe27820
jmp 0x1d2bb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2b8a
leaq 0x5a42ff(%rip), %rax    # 0x776e80
movq %rax, 0xc54c98(%rip)    # 0xe27820
jmp 0x1d2bb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2ba6
leaq 0x2c1e53(%rip), %rax    # 0x4949f0
movq %rax, 0xc54c7c(%rip)    # 0xe27820
jmp 0x1d2bb4
leaq 0xc4b83(%rip), %rax     # 0x297730
movq %rax, 0xc54c6c(%rip)    # 0xe27820
jmp 0x1d2bb6
jmp 0x1d2bb8
movq 0xc54c61(%rip), %rax    # 0xe27820
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_dispatch.c
// Function: parasail_sg_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d2c2e
leaq 0x94f11b(%rip), %rax    # 0xb21d40
movq %rax, 0xc54bfc(%rip)    # 0xe27828
jmp 0x1d2c78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2c4a
leaq 0x5a915f(%rip), %rax    # 0x77bda0
movq %rax, 0xc54be0(%rip)    # 0xe27828
jmp 0x1d2c76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2c66
leaq 0x2c6ef3(%rip), %rax    # 0x499b50
movq %rax, 0xc54bc4(%rip)    # 0xe27828
jmp 0x1d2c74
leaq 0xc4ac3(%rip), %rax     # 0x297730
movq %rax, 0xc54bb4(%rip)    # 0xe27828
jmp 0x1d2c76
jmp 0x1d2c78
movq 0xc54ba9(%rip), %rax    # 0xe27828
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_dispatch.c
// Function: parasail_sg_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d2cee
leaq 0x955a8b(%rip), %rax    # 0xb28770
movq %rax, 0xc54b44(%rip)    # 0xe27830
jmp 0x1d2d38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2d0a
leaq 0x5ae54f(%rip), %rax    # 0x781250
movq %rax, 0xc54b28(%rip)    # 0xe27830
jmp 0x1d2d36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2d26
leaq 0x2cc3f3(%rip), %rax    # 0x49f110
movq %rax, 0xc54b0c(%rip)    # 0xe27830
jmp 0x1d2d34
leaq 0xc4a03(%rip), %rax     # 0x297730
movq %rax, 0xc54afc(%rip)    # 0xe27830
jmp 0x1d2d36
jmp 0x1d2d38
movq 0xc54af1(%rip), %rax    # 0xe27830
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_dispatch.c
// Function: parasail_sg_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d2dae
leaq 0x95debb(%rip), %rax    # 0xb30c60
movq %rax, 0xc54a8c(%rip)    # 0xe27838
jmp 0x1d2df8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2dca
leaq 0x5b44ef(%rip), %rax    # 0x7872b0
movq %rax, 0xc54a70(%rip)    # 0xe27838
jmp 0x1d2df6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2de6
leaq 0x2d26a3(%rip), %rax    # 0x4a5480
movq %rax, 0xc54a54(%rip)    # 0xe27838
jmp 0x1d2df4
leaq 0xc4943(%rip), %rax     # 0x297730
movq %rax, 0xc54a44(%rip)    # 0xe27838
jmp 0x1d2df6
jmp 0x1d2df8
movq 0xc54a39(%rip), %rax    # 0xe27838
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_dispatch.c
// Function: parasail_sg_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d2e6e
leaq 0x9150db(%rip), %rax    # 0xae7f40
movq %rax, 0xc549d4(%rip)    # 0xe27840
jmp 0x1d2eb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2e8a
leaq 0x58362f(%rip), %rax    # 0x7564b0
movq %rax, 0xc549b8(%rip)    # 0xe27840
jmp 0x1d2eb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2ea6
leaq 0x2a01f3(%rip), %rax    # 0x473090
movq %rax, 0xc5499c(%rip)    # 0xe27840
jmp 0x1d2eb4
leaq 0xc4883(%rip), %rax     # 0x297730
movq %rax, 0xc5498c(%rip)    # 0xe27840
jmp 0x1d2eb6
jmp 0x1d2eb8
movq 0xc54981(%rip), %rax    # 0xe27840
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_dispatch.c
// Function: parasail_sg_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_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_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d2f2e
leaq 0x91ddcb(%rip), %rax    # 0xaf0cf0
movq %rax, 0xc5491c(%rip)    # 0xe27848
jmp 0x1d2f78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d2f4a
leaq 0x58980f(%rip), %rax    # 0x75c750
movq %rax, 0xc54900(%rip)    # 0xe27848
jmp 0x1d2f76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d2f66
leaq 0x2a6703(%rip), %rax    # 0x479660
movq %rax, 0xc548e4(%rip)    # 0xe27848
jmp 0x1d2f74
leaq 0xc47c3(%rip), %rax     # 0x297730
movq %rax, 0xc548d4(%rip)    # 0xe27848
jmp 0x1d2f76
jmp 0x1d2f78
movq 0xc548c9(%rip), %rax    # 0xe27848
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_dispatch.c
// Function: parasail_sg_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_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_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d2fee
leaq 0x92a63b(%rip), %rax    # 0xafd620
movq %rax, 0xc54864(%rip)    # 0xe27850
jmp 0x1d3038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d300a
leaq 0x59152f(%rip), %rax    # 0x764530
movq %rax, 0xc54848(%rip)    # 0xe27850
jmp 0x1d3036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3026
leaq 0x2ae693(%rip), %rax    # 0x4816b0
movq %rax, 0xc5482c(%rip)    # 0xe27850
jmp 0x1d3034
leaq 0xc4703(%rip), %rax     # 0x297730
movq %rax, 0xc5481c(%rip)    # 0xe27850
jmp 0x1d3036
jmp 0x1d3038
movq 0xc54811(%rip), %rax    # 0xe27850
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_dispatch.c
// Function: parasail_sg_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_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_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_rowcol_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1d30ae
leaq 0x93e08b(%rip), %rax    # 0xb11130
movq %rax, 0xc547ac(%rip)    # 0xe27858
jmp 0x1d30f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d30ca
leaq 0x59c6cf(%rip), %rax    # 0x76f790
movq %rax, 0xc54790(%rip)    # 0xe27858
jmp 0x1d30f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d30e6
leaq 0x2b9ed3(%rip), %rax    # 0x48cfb0
movq %rax, 0xc54774(%rip)    # 0xe27858
jmp 0x1d30f4
leaq 0xc4643(%rip), %rax     # 0x297730
movq %rax, 0xc54764(%rip)    # 0xe27858
jmp 0x1d30f6
jmp 0x1d30f8
movq 0xc54759(%rip), %rax    # 0xe27858
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_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d316e
leaq 0x969d7b(%rip), %rax    # 0xb3cee0
movq %rax, 0xc546f4(%rip)    # 0xe27860
jmp 0x1d31b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d318a
leaq 0x5bf76f(%rip), %rax    # 0x7928f0
movq %rax, 0xc546d8(%rip)    # 0xe27860
jmp 0x1d31b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d31a6
leaq 0x2db673(%rip), %rax    # 0x4ae810
movq %rax, 0xc546bc(%rip)    # 0xe27860
jmp 0x1d31b4
leaq 0xc64e3(%rip), %rax     # 0x299690
movq %rax, 0xc546ac(%rip)    # 0xe27860
jmp 0x1d31b6
jmp 0x1d31b8
movq 0xc546a1(%rip), %rax    # 0xe27860
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_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d322e
leaq 0x977deb(%rip), %rax    # 0xb4b010
movq %rax, 0xc5463c(%rip)    # 0xe27868
jmp 0x1d3278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d324a
leaq 0x5cac2f(%rip), %rax    # 0x79de70
movq %rax, 0xc54620(%rip)    # 0xe27868
jmp 0x1d3276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3266
leaq 0x2e5f13(%rip), %rax    # 0x4b9170
movq %rax, 0xc54604(%rip)    # 0xe27868
jmp 0x1d3274
leaq 0xc6423(%rip), %rax     # 0x299690
movq %rax, 0xc545f4(%rip)    # 0xe27868
jmp 0x1d3276
jmp 0x1d3278
movq 0xc545e9(%rip), %rax    # 0xe27868
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_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d32ee
leaq 0x9877fb(%rip), %rax    # 0xb5aae0
movq %rax, 0xc54584(%rip)    # 0xe27870
jmp 0x1d3338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d330a
leaq 0x5d699f(%rip), %rax    # 0x7a9ca0
movq %rax, 0xc54568(%rip)    # 0xe27870
jmp 0x1d3336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3326
leaq 0x2f0f23(%rip), %rax    # 0x4c4240
movq %rax, 0xc5454c(%rip)    # 0xe27870
jmp 0x1d3334
leaq 0xc6363(%rip), %rax     # 0x299690
movq %rax, 0xc5453c(%rip)    # 0xe27870
jmp 0x1d3336
jmp 0x1d3338
movq 0xc54531(%rip), %rax    # 0xe27870
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_dispatch.c
// Function: parasail_sg_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d33ae
leaq 0x99a13b(%rip), %rax    # 0xb6d4e0
movq %rax, 0xc544cc(%rip)    # 0xe27878
jmp 0x1d33f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d33ca
leaq 0x5e352f(%rip), %rax    # 0x7b68f0
movq %rax, 0xc544b0(%rip)    # 0xe27878
jmp 0x1d33f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d33e6
leaq 0x2fcf13(%rip), %rax    # 0x4d02f0
movq %rax, 0xc54494(%rip)    # 0xe27878
jmp 0x1d33f4
leaq 0xc62a3(%rip), %rax     # 0x299690
movq %rax, 0xc54484(%rip)    # 0xe27878
jmp 0x1d33f6
jmp 0x1d33f8
movq 0xc54479(%rip), %rax    # 0xe27878
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_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d346e
leaq 0x9f3d3b(%rip), %rax    # 0xbc71a0
movq %rax, 0xc54414(%rip)    # 0xe27880
jmp 0x1d34b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d348a
leaq 0x62025f(%rip), %rax    # 0x7f36e0
movq %rax, 0xc543f8(%rip)    # 0xe27880
jmp 0x1d34b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d34a6
leaq 0x338303(%rip), %rax    # 0x50b7a0
movq %rax, 0xc543dc(%rip)    # 0xe27880
jmp 0x1d34b4
leaq 0xc4283(%rip), %rax     # 0x297730
movq %rax, 0xc543cc(%rip)    # 0xe27880
jmp 0x1d34b6
jmp 0x1d34b8
movq 0xc543c1(%rip), %rax    # 0xe27880
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_dispatch.c
// Function: parasail_sg_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d352e
leaq 0x9ff95b(%rip), %rax    # 0xbd2e80
movq %rax, 0xc5435c(%rip)    # 0xe27888
jmp 0x1d3578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d354a
leaq 0x62a05f(%rip), %rax    # 0x7fd5a0
movq %rax, 0xc54340(%rip)    # 0xe27888
jmp 0x1d3576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3566
leaq 0x341b53(%rip), %rax    # 0x5150b0
movq %rax, 0xc54324(%rip)    # 0xe27888
jmp 0x1d3574
leaq 0xc41c3(%rip), %rax     # 0x297730
movq %rax, 0xc54314(%rip)    # 0xe27888
jmp 0x1d3576
jmp 0x1d3578
movq 0xc54309(%rip), %rax    # 0xe27888
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)