LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e4fee
leaq 0x9e1d5b(%rip), %rax    # 0xbc6d40
movq %rax, 0xc43154(%rip)    # 0xe28140
jmp 0x1e5038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e500a
leaq 0x60e27f(%rip), %rax    # 0x7f3280
movq %rax, 0xc43138(%rip)    # 0xe28140
jmp 0x1e5036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5026
leaq 0x326323(%rip), %rax    # 0x50b340
movq %rax, 0xc4311c(%rip)    # 0xe28140
jmp 0x1e5034
leaq 0xb22a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc4310c(%rip)    # 0xe28140
jmp 0x1e5036
jmp 0x1e5038
movq 0xc43101(%rip), %rax    # 0xe28140
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e50ae
leaq 0x9ed97b(%rip), %rax    # 0xbd2a20
movq %rax, 0xc4309c(%rip)    # 0xe28148
jmp 0x1e50f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e50ca
leaq 0x61807f(%rip), %rax    # 0x7fd140
movq %rax, 0xc43080(%rip)    # 0xe28148
jmp 0x1e50f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e50e6
leaq 0x32fb73(%rip), %rax    # 0x514c50
movq %rax, 0xc43064(%rip)    # 0xe28148
jmp 0x1e50f4
leaq 0xb21e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc43054(%rip)    # 0xe28148
jmp 0x1e50f6
jmp 0x1e50f8
movq 0xc43049(%rip), %rax    # 0xe28148
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e516e
leaq 0x9fa60b(%rip), %rax    # 0xbdf770
movq %rax, 0xc42fe4(%rip)    # 0xe28150
jmp 0x1e51b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e518a
leaq 0x62261f(%rip), %rax    # 0x8077a0
movq %rax, 0xc42fc8(%rip)    # 0xe28150
jmp 0x1e51b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e51a6
leaq 0x339933(%rip), %rax    # 0x51ead0
movq %rax, 0xc42fac(%rip)    # 0xe28150
jmp 0x1e51b4
leaq 0xb2123(%rip), %rax     # 0x2972d0
movq %rax, 0xc42f9c(%rip)    # 0xe28150
jmp 0x1e51b6
jmp 0x1e51b8
movq 0xc42f91(%rip), %rax    # 0xe28150
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e522e
leaq 0xa093ab(%rip), %rax    # 0xbee5d0
movq %rax, 0xc42f2c(%rip)    # 0xe28158
jmp 0x1e5278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e524a
leaq 0x62dbef(%rip), %rax    # 0x812e30
movq %rax, 0xc42f10(%rip)    # 0xe28158
jmp 0x1e5276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5266
leaq 0x344703(%rip), %rax    # 0x529960
movq %rax, 0xc42ef4(%rip)    # 0xe28158
jmp 0x1e5274
leaq 0xb2063(%rip), %rax     # 0x2972d0
movq %rax, 0xc42ee4(%rip)    # 0xe28158
jmp 0x1e5276
jmp 0x1e5278
movq 0xc42ed9(%rip), %rax    # 0xe28158
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e52ee
leaq 0x99737b(%rip), %rax    # 0xb7c660
movq %rax, 0xc42e74(%rip)    # 0xe28160
jmp 0x1e5338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e530a
leaq 0x5dc17f(%rip), %rax    # 0x7c1480
movq %rax, 0xc42e58(%rip)    # 0xe28160
jmp 0x1e5336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5326
leaq 0x2f5353(%rip), %rax    # 0x4da670
movq %rax, 0xc42e3c(%rip)    # 0xe28160
jmp 0x1e5334
leaq 0xb1fa3(%rip), %rax     # 0x2972d0
movq %rax, 0xc42e2c(%rip)    # 0xe28160
jmp 0x1e5336
jmp 0x1e5338
movq 0xc42e21(%rip), %rax    # 0xe28160
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e53ae
leaq 0x9a526b(%rip), %rax    # 0xb8a610
movq %rax, 0xc42dbc(%rip)    # 0xe28168
jmp 0x1e53f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e53ca
leaq 0x5e63af(%rip), %rax    # 0x7cb770
movq %rax, 0xc42da0(%rip)    # 0xe28168
jmp 0x1e53f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e53e6
leaq 0x2ff0d3(%rip), %rax    # 0x4e44b0
movq %rax, 0xc42d84(%rip)    # 0xe28168
jmp 0x1e53f4
leaq 0xb1ee3(%rip), %rax     # 0x2972d0
movq %rax, 0xc42d74(%rip)    # 0xe28168
jmp 0x1e53f6
jmp 0x1e53f8
movq 0xc42d69(%rip), %rax    # 0xe28168
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e546e
leaq 0x9b717b(%rip), %rax    # 0xb9c5e0
movq %rax, 0xc42d04(%rip)    # 0xe28170
jmp 0x1e54b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e548a
leaq 0x5f237f(%rip), %rax    # 0x7d7800
movq %rax, 0xc42ce8(%rip)    # 0xe28170
jmp 0x1e54b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e54a6
leaq 0x30aa63(%rip), %rax    # 0x4eff00
movq %rax, 0xc42ccc(%rip)    # 0xe28170
jmp 0x1e54b4
leaq 0xb1e23(%rip), %rax     # 0x2972d0
movq %rax, 0xc42cbc(%rip)    # 0xe28170
jmp 0x1e54b6
jmp 0x1e54b8
movq 0xc42cb1(%rip), %rax    # 0xe28170
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e552e
leaq 0x9d0a2b(%rip), %rax    # 0xbb5f50
movq %rax, 0xc42c4c(%rip)    # 0xe28178
jmp 0x1e5578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e554a
leaq 0x601a5f(%rip), %rax    # 0x7e6fa0
movq %rax, 0xc42c30(%rip)    # 0xe28178
jmp 0x1e5576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5566
leaq 0x319fe3(%rip), %rax    # 0x4ff540
movq %rax, 0xc42c14(%rip)    # 0xe28178
jmp 0x1e5574
leaq 0xb1d63(%rip), %rax     # 0x2972d0
movq %rax, 0xc42c04(%rip)    # 0xe28178
jmp 0x1e5576
jmp 0x1e5578
movq 0xc42bf9(%rip), %rax    # 0xe28178
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e55ee
leaq 0xa13e0b(%rip), %rax    # 0xbf93f0
movq %rax, 0xc42b94(%rip)    # 0xe28180
jmp 0x1e5638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e560a
leaq 0x6360ef(%rip), %rax    # 0x81b6f0
movq %rax, 0xc42b78(%rip)    # 0xe28180
jmp 0x1e5636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5626
leaq 0x34c843(%rip), %rax    # 0x531e60
movq %rax, 0xc42b5c(%rip)    # 0xe28180
jmp 0x1e5634
leaq 0xb3c03(%rip), %rax     # 0x299230
movq %rax, 0xc42b4c(%rip)    # 0xe28180
jmp 0x1e5636
jmp 0x1e5638
movq 0xc42b41(%rip), %rax    # 0xe28180
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e56ae
leaq 0xa1c44b(%rip), %rax    # 0xc01af0
movq %rax, 0xc42adc(%rip)    # 0xe28188
jmp 0x1e56f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e56ca
leaq 0x63c9df(%rip), %rax    # 0x8220a0
movq %rax, 0xc42ac0(%rip)    # 0xe28188
jmp 0x1e56f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e56e6
leaq 0x353223(%rip), %rax    # 0x538900
movq %rax, 0xc42aa4(%rip)    # 0xe28188
jmp 0x1e56f4
leaq 0xb3b43(%rip), %rax     # 0x299230
movq %rax, 0xc42a94(%rip)    # 0xe28188
jmp 0x1e56f6
jmp 0x1e56f8
movq 0xc42a89(%rip), %rax    # 0xe28188
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e576e
leaq 0xa2654b(%rip), %rax    # 0xc0bcb0
movq %rax, 0xc42a24(%rip)    # 0xe28190
jmp 0x1e57b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e578a
leaq 0x643daf(%rip), %rax    # 0x829530
movq %rax, 0xc42a08(%rip)    # 0xe28190
jmp 0x1e57b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e57a6
leaq 0x35a7a3(%rip), %rax    # 0x53ff40
movq %rax, 0xc429ec(%rip)    # 0xe28190
jmp 0x1e57b4
leaq 0xb3a83(%rip), %rax     # 0x299230
movq %rax, 0xc429dc(%rip)    # 0xe28190
jmp 0x1e57b6
jmp 0x1e57b8
movq 0xc429d1(%rip), %rax    # 0xe28190
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e582e
leaq 0xa3389b(%rip), %rax    # 0xc190c0
movq %rax, 0xc4296c(%rip)    # 0xe28198
jmp 0x1e5878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e584a
leaq 0x64c44f(%rip), %rax    # 0x831c90
movq %rax, 0xc42950(%rip)    # 0xe28198
jmp 0x1e5876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5866
leaq 0x363293(%rip), %rax    # 0x548af0
movq %rax, 0xc42934(%rip)    # 0xe28198
jmp 0x1e5874
leaq 0xb39c3(%rip), %rax     # 0x299230
movq %rax, 0xc42924(%rip)    # 0xe28198
jmp 0x1e5876
jmp 0x1e5878
movq 0xc42919(%rip), %rax    # 0xe28198
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e58ee
leaq 0xa7d00b(%rip), %rax    # 0xc628f0
movq %rax, 0xc428b4(%rip)    # 0xe281a0
jmp 0x1e5938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e590a
leaq 0x67ae3f(%rip), %rax    # 0x860740
movq %rax, 0xc42898(%rip)    # 0xe281a0
jmp 0x1e5936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5926
leaq 0x392683(%rip), %rax    # 0x577fa0
movq %rax, 0xc4287c(%rip)    # 0xe281a0
jmp 0x1e5934
leaq 0xb19a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc4286c(%rip)    # 0xe281a0
jmp 0x1e5936
jmp 0x1e5938
movq 0xc42861(%rip), %rax    # 0xe281a0
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e59ae
leaq 0xa86e0b(%rip), %rax    # 0xc6c7b0
movq %rax, 0xc427fc(%rip)    # 0xe281a8
jmp 0x1e59f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e59ca
leaq 0x682dbf(%rip), %rax    # 0x868780
movq %rax, 0xc427e0(%rip)    # 0xe281a8
jmp 0x1e59f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e59e6
leaq 0x39a5b3(%rip), %rax    # 0x57ff90
movq %rax, 0xc427c4(%rip)    # 0xe281a8
jmp 0x1e59f4
leaq 0xb18e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc427b4(%rip)    # 0xe281a8
jmp 0x1e59f6
jmp 0x1e59f8
movq 0xc427a9(%rip), %rax    # 0xe281a8
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e5a6e
leaq 0xa9267b(%rip), %rax    # 0xc780e0
movq %rax, 0xc42744(%rip)    # 0xe281b0
jmp 0x1e5ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5a8a
leaq 0x68ba1f(%rip), %rax    # 0x8714a0
movq %rax, 0xc42728(%rip)    # 0xe281b0
jmp 0x1e5ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5aa6
leaq 0x3a31e3(%rip), %rax    # 0x588c80
movq %rax, 0xc4270c(%rip)    # 0xe281b0
jmp 0x1e5ab4
leaq 0xb1823(%rip), %rax     # 0x2972d0
movq %rax, 0xc426fc(%rip)    # 0xe281b0
jmp 0x1e5ab6
jmp 0x1e5ab8
movq 0xc426f1(%rip), %rax    # 0xe281b0
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e5b2e
leaq 0xaa0dfb(%rip), %rax    # 0xc86920
movq %rax, 0xc4268c(%rip)    # 0xe281b8
jmp 0x1e5b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5b4a
leaq 0x695aff(%rip), %rax    # 0x87b640
movq %rax, 0xc42670(%rip)    # 0xe281b8
jmp 0x1e5b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5b66
leaq 0x3ad583(%rip), %rax    # 0x5930e0
movq %rax, 0xc42654(%rip)    # 0xe281b8
jmp 0x1e5b74
leaq 0xb1763(%rip), %rax     # 0x2972d0
movq %rax, 0xc42644(%rip)    # 0xe281b8
jmp 0x1e5b76
jmp 0x1e5b78
movq 0xc42639(%rip), %rax    # 0xe281b8
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e5bee
leaq 0xa3e6cb(%rip), %rax    # 0xc242b0
movq %rax, 0xc425d4(%rip)    # 0xe281c0
jmp 0x1e5c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5c0a
leaq 0x6538af(%rip), %rax    # 0x8394b0
movq %rax, 0xc425b8(%rip)    # 0xe281c0
jmp 0x1e5c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5c26
leaq 0x36a753(%rip), %rax    # 0x550370
movq %rax, 0xc4259c(%rip)    # 0xe281c0
jmp 0x1e5c34
leaq 0xb16a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc4258c(%rip)    # 0xe281c0
jmp 0x1e5c36
jmp 0x1e5c38
movq 0xc42581(%rip), %rax    # 0xe281c0
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e5cae
leaq 0xa48bfb(%rip), %rax    # 0xc2e8a0
movq %rax, 0xc4251c(%rip)    # 0xe281c8
jmp 0x1e5cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5cca
leaq 0x65aa2f(%rip), %rax    # 0x8406f0
movq %rax, 0xc42500(%rip)    # 0xe281c8
jmp 0x1e5cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5ce6
leaq 0x371903(%rip), %rax    # 0x5575e0
movq %rax, 0xc424e4(%rip)    # 0xe281c8
jmp 0x1e5cf4
leaq 0xb15e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc424d4(%rip)    # 0xe281c8
jmp 0x1e5cf6
jmp 0x1e5cf8
movq 0xc424c9(%rip), %rax    # 0xe281c8
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e5d6e
leaq 0xa5751b(%rip), %rax    # 0xc3d280
movq %rax, 0xc42464(%rip)    # 0xe281d0
jmp 0x1e5db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e5d8a
leaq 0x663b3f(%rip), %rax    # 0x8498c0
movq %rax, 0xc42448(%rip)    # 0xe281d0
jmp 0x1e5db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e5da6
leaq 0x37ab33(%rip), %rax    # 0x5608d0
movq %rax, 0xc4242c(%rip)    # 0xe281d0
jmp 0x1e5db4
leaq 0xb1523(%rip), %rax     # 0x2972d0
movq %rax, 0xc4241c(%rip)    # 0xe281d0
jmp 0x1e5db6
jmp 0x1e5db8
movq 0xc42411(%rip), %rax    # 0xe281d0
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)