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_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d35ee
leaq 0xa0c5eb(%rip), %rax    # 0xbdfbd0
movq %rax, 0xc542a4(%rip)    # 0xe27890
jmp 0x1d3638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d360a
leaq 0x6345ff(%rip), %rax    # 0x807c00
movq %rax, 0xc54288(%rip)    # 0xe27890
jmp 0x1d3636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3626
leaq 0x34b913(%rip), %rax    # 0x51ef30
movq %rax, 0xc5426c(%rip)    # 0xe27890
jmp 0x1d3634
leaq 0xc4103(%rip), %rax     # 0x297730
movq %rax, 0xc5425c(%rip)    # 0xe27890
jmp 0x1d3636
jmp 0x1d3638
movq 0xc54251(%rip), %rax    # 0xe27890
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_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d36ae
leaq 0xa1b38b(%rip), %rax    # 0xbeea30
movq %rax, 0xc541ec(%rip)    # 0xe27898
jmp 0x1d36f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d36ca
leaq 0x63fbcf(%rip), %rax    # 0x813290
movq %rax, 0xc541d0(%rip)    # 0xe27898
jmp 0x1d36f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d36e6
leaq 0x3566e3(%rip), %rax    # 0x529dc0
movq %rax, 0xc541b4(%rip)    # 0xe27898
jmp 0x1d36f4
leaq 0xc4043(%rip), %rax     # 0x297730
movq %rax, 0xc541a4(%rip)    # 0xe27898
jmp 0x1d36f6
jmp 0x1d36f8
movq 0xc54199(%rip), %rax    # 0xe27898
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_diag_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d376e
leaq 0x9a935b(%rip), %rax    # 0xb7cac0
movq %rax, 0xc54134(%rip)    # 0xe278a0
jmp 0x1d37b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d378a
leaq 0x5ee15f(%rip), %rax    # 0x7c18e0
movq %rax, 0xc54118(%rip)    # 0xe278a0
jmp 0x1d37b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d37a6
leaq 0x307333(%rip), %rax    # 0x4daad0
movq %rax, 0xc540fc(%rip)    # 0xe278a0
jmp 0x1d37b4
leaq 0xc3f83(%rip), %rax     # 0x297730
movq %rax, 0xc540ec(%rip)    # 0xe278a0
jmp 0x1d37b6
jmp 0x1d37b8
movq 0xc540e1(%rip), %rax    # 0xe278a0
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_diag_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d382e
leaq 0x9b724b(%rip), %rax    # 0xb8aa70
movq %rax, 0xc5407c(%rip)    # 0xe278a8
jmp 0x1d3878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d384a
leaq 0x5f838f(%rip), %rax    # 0x7cbbd0
movq %rax, 0xc54060(%rip)    # 0xe278a8
jmp 0x1d3876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3866
leaq 0x3110b3(%rip), %rax    # 0x4e4910
movq %rax, 0xc54044(%rip)    # 0xe278a8
jmp 0x1d3874
leaq 0xc3ec3(%rip), %rax     # 0x297730
movq %rax, 0xc54034(%rip)    # 0xe278a8
jmp 0x1d3876
jmp 0x1d3878
movq 0xc54029(%rip), %rax    # 0xe278a8
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_diag_16_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d38ee
leaq 0x9c915b(%rip), %rax    # 0xb9ca40
movq %rax, 0xc53fc4(%rip)    # 0xe278b0
jmp 0x1d3938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d390a
leaq 0x60435f(%rip), %rax    # 0x7d7c60
movq %rax, 0xc53fa8(%rip)    # 0xe278b0
jmp 0x1d3936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3926
leaq 0x31ca43(%rip), %rax    # 0x4f0360
movq %rax, 0xc53f8c(%rip)    # 0xe278b0
jmp 0x1d3934
leaq 0xc3e03(%rip), %rax     # 0x297730
movq %rax, 0xc53f7c(%rip)    # 0xe278b0
jmp 0x1d3936
jmp 0x1d3938
movq 0xc53f71(%rip), %rax    # 0xe278b0
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_diag_8_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_rowcol_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d39ae
leaq 0x9e2a0b(%rip), %rax    # 0xbb63b0
movq %rax, 0xc53f0c(%rip)    # 0xe278b8
jmp 0x1d39f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d39ca
leaq 0x613a3f(%rip), %rax    # 0x7e7400
movq %rax, 0xc53ef0(%rip)    # 0xe278b8
jmp 0x1d39f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d39e6
leaq 0x32bfc3(%rip), %rax    # 0x4ff9a0
movq %rax, 0xc53ed4(%rip)    # 0xe278b8
jmp 0x1d39f4
leaq 0xc3d43(%rip), %rax     # 0x297730
movq %rax, 0xc53ec4(%rip)    # 0xe278b8
jmp 0x1d39f6
jmp 0x1d39f8
movq 0xc53eb9(%rip), %rax    # 0xe278b8
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_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_64_pointer = parasail_sg_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_trace_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3a6e
leaq 0xa25deb(%rip), %rax    # 0xbf9850
movq %rax, 0xc53e54(%rip)    # 0xe278c0
jmp 0x1d3ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3a8a
leaq 0x6480cf(%rip), %rax    # 0x81bb50
movq %rax, 0xc53e38(%rip)    # 0xe278c0
jmp 0x1d3ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3aa6
leaq 0x35e823(%rip), %rax    # 0x5322c0
movq %rax, 0xc53e1c(%rip)    # 0xe278c0
jmp 0x1d3ab4
leaq 0xc5be3(%rip), %rax     # 0x299690
movq %rax, 0xc53e0c(%rip)    # 0xe278c0
jmp 0x1d3ab6
jmp 0x1d3ab8
movq 0xc53e01(%rip), %rax    # 0xe278c0
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_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_32_pointer = parasail_sg_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_trace_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3b2e
leaq 0xa2e42b(%rip), %rax    # 0xc01f50
movq %rax, 0xc53d9c(%rip)    # 0xe278c8
jmp 0x1d3b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3b4a
leaq 0x64e9bf(%rip), %rax    # 0x822500
movq %rax, 0xc53d80(%rip)    # 0xe278c8
jmp 0x1d3b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3b66
leaq 0x365203(%rip), %rax    # 0x538d60
movq %rax, 0xc53d64(%rip)    # 0xe278c8
jmp 0x1d3b74
leaq 0xc5b23(%rip), %rax     # 0x299690
movq %rax, 0xc53d54(%rip)    # 0xe278c8
jmp 0x1d3b76
jmp 0x1d3b78
movq 0xc53d49(%rip), %rax    # 0xe278c8
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_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_16_pointer = parasail_sg_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_trace_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3bee
leaq 0xa3852b(%rip), %rax    # 0xc0c110
movq %rax, 0xc53ce4(%rip)    # 0xe278d0
jmp 0x1d3c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3c0a
leaq 0x655d8f(%rip), %rax    # 0x829990
movq %rax, 0xc53cc8(%rip)    # 0xe278d0
jmp 0x1d3c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3c26
leaq 0x36c783(%rip), %rax    # 0x5403a0
movq %rax, 0xc53cac(%rip)    # 0xe278d0
jmp 0x1d3c34
leaq 0xc5a63(%rip), %rax     # 0x299690
movq %rax, 0xc53c9c(%rip)    # 0xe278d0
jmp 0x1d3c36
jmp 0x1d3c38
movq 0xc53c91(%rip), %rax    # 0xe278d0
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_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_scan_8_pointer = parasail_sg_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_trace_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_trace_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3cae
leaq 0xa4587b(%rip), %rax    # 0xc19520
movq %rax, 0xc53c2c(%rip)    # 0xe278d8
jmp 0x1d3cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3cca
leaq 0x65e42f(%rip), %rax    # 0x8320f0
movq %rax, 0xc53c10(%rip)    # 0xe278d8
jmp 0x1d3cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3ce6
leaq 0x375273(%rip), %rax    # 0x548f50
movq %rax, 0xc53bf4(%rip)    # 0xe278d8
jmp 0x1d3cf4
leaq 0xc59a3(%rip), %rax     # 0x299690
movq %rax, 0xc53be4(%rip)    # 0xe278d8
jmp 0x1d3cf6
jmp 0x1d3cf8
movq 0xc53bd9(%rip), %rax    # 0xe278d8
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_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_trace_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_64_pointer = parasail_sg_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_trace_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3d6e
leaq 0xa8efeb(%rip), %rax    # 0xc62d50
movq %rax, 0xc53b74(%rip)    # 0xe278e0
jmp 0x1d3db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3d8a
leaq 0x68ce1f(%rip), %rax    # 0x860ba0
movq %rax, 0xc53b58(%rip)    # 0xe278e0
jmp 0x1d3db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3da6
leaq 0x3a4663(%rip), %rax    # 0x578400
movq %rax, 0xc53b3c(%rip)    # 0xe278e0
jmp 0x1d3db4
leaq 0xc3983(%rip), %rax     # 0x297730
movq %rax, 0xc53b2c(%rip)    # 0xe278e0
jmp 0x1d3db6
jmp 0x1d3db8
movq 0xc53b21(%rip), %rax    # 0xe278e0
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_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_trace_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_32_pointer = parasail_sg_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_trace_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3e2e
leaq 0xa98deb(%rip), %rax    # 0xc6cc10
movq %rax, 0xc53abc(%rip)    # 0xe278e8
jmp 0x1d3e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3e4a
leaq 0x694d9f(%rip), %rax    # 0x868be0
movq %rax, 0xc53aa0(%rip)    # 0xe278e8
jmp 0x1d3e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3e66
leaq 0x3ac593(%rip), %rax    # 0x5803f0
movq %rax, 0xc53a84(%rip)    # 0xe278e8
jmp 0x1d3e74
leaq 0xc38c3(%rip), %rax     # 0x297730
movq %rax, 0xc53a74(%rip)    # 0xe278e8
jmp 0x1d3e76
jmp 0x1d3e78
movq 0xc53a69(%rip), %rax    # 0xe278e8
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_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_trace_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_16_pointer = parasail_sg_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_trace_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3eee
leaq 0xaa465b(%rip), %rax    # 0xc78540
movq %rax, 0xc53a04(%rip)    # 0xe278f0
jmp 0x1d3f38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3f0a
leaq 0x69d9ff(%rip), %rax    # 0x871900
movq %rax, 0xc539e8(%rip)    # 0xe278f0
jmp 0x1d3f36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3f26
leaq 0x3b51c3(%rip), %rax    # 0x5890e0
movq %rax, 0xc539cc(%rip)    # 0xe278f0
jmp 0x1d3f34
leaq 0xc3803(%rip), %rax     # 0x297730
movq %rax, 0xc539bc(%rip)    # 0xe278f0
jmp 0x1d3f36
jmp 0x1d3f38
movq 0xc539b1(%rip), %rax    # 0xe278f0
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_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_trace_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_8_pointer = parasail_sg_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_trace_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_trace_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d3fae
leaq 0xab2ddb(%rip), %rax    # 0xc86d80
movq %rax, 0xc5394c(%rip)    # 0xe278f8
jmp 0x1d3ff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d3fca
leaq 0x6a7adf(%rip), %rax    # 0x87baa0
movq %rax, 0xc53930(%rip)    # 0xe278f8
jmp 0x1d3ff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d3fe6
leaq 0x3bf563(%rip), %rax    # 0x593540
movq %rax, 0xc53914(%rip)    # 0xe278f8
jmp 0x1d3ff4
leaq 0xc3743(%rip), %rax     # 0x297730
movq %rax, 0xc53904(%rip)    # 0xe278f8
jmp 0x1d3ff6
jmp 0x1d3ff8
movq 0xc538f9(%rip), %rax    # 0xe278f8
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_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_trace_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_64_pointer = parasail_sg_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_trace_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d406e
leaq 0xa506ab(%rip), %rax    # 0xc24710
movq %rax, 0xc53894(%rip)    # 0xe27900
jmp 0x1d40b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d408a
leaq 0x66588f(%rip), %rax    # 0x839910
movq %rax, 0xc53878(%rip)    # 0xe27900
jmp 0x1d40b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d40a6
leaq 0x37c733(%rip), %rax    # 0x5507d0
movq %rax, 0xc5385c(%rip)    # 0xe27900
jmp 0x1d40b4
leaq 0xc3683(%rip), %rax     # 0x297730
movq %rax, 0xc5384c(%rip)    # 0xe27900
jmp 0x1d40b6
jmp 0x1d40b8
movq 0xc53841(%rip), %rax    # 0xe27900
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_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_trace_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_32_pointer = parasail_sg_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_trace_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d412e
leaq 0xa5abdb(%rip), %rax    # 0xc2ed00
movq %rax, 0xc537dc(%rip)    # 0xe27908
jmp 0x1d4178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d414a
leaq 0x66ca0f(%rip), %rax    # 0x840b50
movq %rax, 0xc537c0(%rip)    # 0xe27908
jmp 0x1d4176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4166
leaq 0x3838e3(%rip), %rax    # 0x557a40
movq %rax, 0xc537a4(%rip)    # 0xe27908
jmp 0x1d4174
leaq 0xc35c3(%rip), %rax     # 0x297730
movq %rax, 0xc53794(%rip)    # 0xe27908
jmp 0x1d4176
jmp 0x1d4178
movq 0xc53789(%rip), %rax    # 0xe27908
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_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_trace_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_16_pointer = parasail_sg_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_trace_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d41ee
leaq 0xa694fb(%rip), %rax    # 0xc3d6e0
movq %rax, 0xc53724(%rip)    # 0xe27910
jmp 0x1d4238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d420a
leaq 0x675b1f(%rip), %rax    # 0x849d20
movq %rax, 0xc53708(%rip)    # 0xe27910
jmp 0x1d4236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4226
leaq 0x38cb13(%rip), %rax    # 0x560d30
movq %rax, 0xc536ec(%rip)    # 0xe27910
jmp 0x1d4234
leaq 0xc3503(%rip), %rax     # 0x297730
movq %rax, 0xc536dc(%rip)    # 0xe27910
jmp 0x1d4236
jmp 0x1d4238
movq 0xc536d1(%rip), %rax    # 0xe27910
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_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_trace_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_diag_8_pointer = parasail_sg_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_trace_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_trace_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d42ae
leaq 0xa7fffb(%rip), %rax    # 0xc542a0
movq %rax, 0xc5366c(%rip)    # 0xe27918
jmp 0x1d42f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d42ca
leaq 0x68281f(%rip), %rax    # 0x856ae0
movq %rax, 0xc53650(%rip)    # 0xe27918
jmp 0x1d42f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d42e6
leaq 0x399ea3(%rip), %rax    # 0x56e180
movq %rax, 0xc53634(%rip)    # 0xe27918
jmp 0x1d42f4
leaq 0xc3443(%rip), %rax     # 0x297730
movq %rax, 0xc53624(%rip)    # 0xe27918
jmp 0x1d42f6
jmp 0x1d42f8
movq 0xc53619(%rip), %rax    # 0xe27918
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_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_scan_profile_64_pointer = parasail_sg_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_profile_64_pointer = parasail_sg_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_profile_64_pointer = parasail_sg_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_profile_64_pointer = parasail_sg_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_profile_64_pointer = parasail_sg_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d4366
leaq 0x6af553(%rip), %rax    # 0x8838b0
movq %rax, 0xc535bc(%rip)    # 0xe27920
jmp 0x1d43ac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4382
leaq 0x3c6627(%rip), %rax    # 0x59a9a0
movq %rax, 0xc535a0(%rip)    # 0xe27920
jmp 0x1d43aa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d439e
leaq 0xec6cb(%rip), %rax     # 0x2c0a60
movq %rax, 0xc53584(%rip)    # 0xe27920
jmp 0x1d43a8
movq $0x0, -0x8(%rbp)
jmp 0x1d43cb
jmp 0x1d43aa
jmp 0x1d43ac
movq 0xc5356d(%rip), %rax    # 0xe27920
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_scan_profile_32_pointer = parasail_sg_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_profile_32_pointer = parasail_sg_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_profile_32_pointer = parasail_sg_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_profile_32_pointer = parasail_sg_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_profile_32_pointer = parasail_sg_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1d4416
leaq 0x6b5983(%rip), %rax    # 0x889d90
movq %rax, 0xc53514(%rip)    # 0xe27928
jmp 0x1d445c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4432
leaq 0x3cb7f7(%rip), %rax    # 0x59fc20
movq %rax, 0xc534f8(%rip)    # 0xe27928
jmp 0x1d445a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d444e
leaq 0xf1a7b(%rip), %rax     # 0x2c5ec0
movq %rax, 0xc534dc(%rip)    # 0xe27928
jmp 0x1d4458
movq $0x0, -0x8(%rbp)
jmp 0x1d447b
jmp 0x1d445a
jmp 0x1d445c
movq 0xc534c5(%rip), %rax    # 0xe27928
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)