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_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1e41ae
leaq 0x8765cb(%rip), %rax    # 0xa5a770
movq %rax, 0xc43efc(%rip)    # 0xe280a8
jmp 0x1e41f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e41ca
leaq 0x50c0bf(%rip), %rax    # 0x6f0280
movq %rax, 0xc43ee0(%rip)    # 0xe280a8
jmp 0x1e41f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e41e6
leaq 0x22aa23(%rip), %rax    # 0x40ec00
movq %rax, 0xc43ec4(%rip)    # 0xe280a8
jmp 0x1e41f4
leaq 0xb30e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc43eb4(%rip)    # 0xe280a8
jmp 0x1e41f6
jmp 0x1e41f8
movq 0xc43ea9(%rip), %rax    # 0xe280a8
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_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e426e
leaq 0x887e1b(%rip), %rax    # 0xa6c080
movq %rax, 0xc43e44(%rip)    # 0xe280b0
jmp 0x1e42b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e428a
leaq 0x517d4f(%rip), %rax    # 0x6fbfd0
movq %rax, 0xc43e28(%rip)    # 0xe280b0
jmp 0x1e42b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e42a6
leaq 0x236053(%rip), %rax    # 0x41a2f0
movq %rax, 0xc43e0c(%rip)    # 0xe280b0
jmp 0x1e42b4
leaq 0xb3023(%rip), %rax     # 0x2972d0
movq %rax, 0xc43dfc(%rip)    # 0xe280b0
jmp 0x1e42b6
jmp 0x1e42b8
movq 0xc43df1(%rip), %rax    # 0xe280b0
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_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e432e
leaq 0x8a084b(%rip), %rax    # 0xa84b70
movq %rax, 0xc43d8c(%rip)    # 0xe280b8
jmp 0x1e4378
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e434a
leaq 0x526daf(%rip), %rax    # 0x70b0f0
movq %rax, 0xc43d70(%rip)    # 0xe280b8
jmp 0x1e4376
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4366
leaq 0x244f23(%rip), %rax    # 0x429280
movq %rax, 0xc43d54(%rip)    # 0xe280b8
jmp 0x1e4374
leaq 0xb2f63(%rip), %rax     # 0x2972d0
movq %rax, 0xc43d44(%rip)    # 0xe280b8
jmp 0x1e4376
jmp 0x1e4378
movq 0xc43d39(%rip), %rax    # 0xe280b8
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_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e43ee
leaq 0x8e1e0b(%rip), %rax    # 0xac61f0
movq %rax, 0xc43cd4(%rip)    # 0xe280c0
jmp 0x1e4438
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e440a
leaq 0x559a6f(%rip), %rax    # 0x73de70
movq %rax, 0xc43cb8(%rip)    # 0xe280c0
jmp 0x1e4436
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4426
leaq 0x275d43(%rip), %rax    # 0x45a160
movq %rax, 0xc43c9c(%rip)    # 0xe280c0
jmp 0x1e4434
leaq 0xb4e03(%rip), %rax     # 0x299230
movq %rax, 0xc43c8c(%rip)    # 0xe280c0
jmp 0x1e4436
jmp 0x1e4438
movq 0xc43c81(%rip), %rax    # 0xe280c0
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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e44ae
leaq 0x8e891b(%rip), %rax    # 0xaccdc0
movq %rax, 0xc43c1c(%rip)    # 0xe280c8
jmp 0x1e44f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e44ca
leaq 0x55f0ff(%rip), %rax    # 0x7435c0
movq %rax, 0xc43c00(%rip)    # 0xe280c8
jmp 0x1e44f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e44e6
leaq 0x27b673(%rip), %rax    # 0x45fb50
movq %rax, 0xc43be4(%rip)    # 0xe280c8
jmp 0x1e44f4
leaq 0xb4d43(%rip), %rax     # 0x299230
movq %rax, 0xc43bd4(%rip)    # 0xe280c8
jmp 0x1e44f6
jmp 0x1e44f8
movq 0xc43bc9(%rip), %rax    # 0xe280c8
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_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e456e
leaq 0x8f064b(%rip), %rax    # 0xad4bb0
movq %rax, 0xc43b64(%rip)    # 0xe280d0
jmp 0x1e45b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e458a
leaq 0x564e2f(%rip), %rax    # 0x7493b0
movq %rax, 0xc43b48(%rip)    # 0xe280d0
jmp 0x1e45b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e45a6
leaq 0x281523(%rip), %rax    # 0x465ac0
movq %rax, 0xc43b2c(%rip)    # 0xe280d0
jmp 0x1e45b4
leaq 0xb4c83(%rip), %rax     # 0x299230
movq %rax, 0xc43b1c(%rip)    # 0xe280d0
jmp 0x1e45b6
jmp 0x1e45b8
movq 0xc43b11(%rip), %rax    # 0xe280d0
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_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e462e
leaq 0x8fa57b(%rip), %rax    # 0xadeba0
movq %rax, 0xc43aac(%rip)    # 0xe280d8
jmp 0x1e4678
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e464a
leaq 0x56b68f(%rip), %rax    # 0x74fcd0
movq %rax, 0xc43a90(%rip)    # 0xe280d8
jmp 0x1e4676
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4666
leaq 0x2880a3(%rip), %rax    # 0x46c700
movq %rax, 0xc43a74(%rip)    # 0xe280d8
jmp 0x1e4674
leaq 0xb4bc3(%rip), %rax     # 0x299230
movq %rax, 0xc43a64(%rip)    # 0xe280d8
jmp 0x1e4676
jmp 0x1e4678
movq 0xc43a59(%rip), %rax    # 0xe280d8
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_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e46ee
leaq 0x9374db(%rip), %rax    # 0xb1bbc0
movq %rax, 0xc439f4(%rip)    # 0xe280e0
jmp 0x1e4738
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e470a
leaq 0x59231f(%rip), %rax    # 0x776a20
movq %rax, 0xc439d8(%rip)    # 0xe280e0
jmp 0x1e4736
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4726
leaq 0x2afe73(%rip), %rax    # 0x494590
movq %rax, 0xc439bc(%rip)    # 0xe280e0
jmp 0x1e4734
leaq 0xb2ba3(%rip), %rax     # 0x2972d0
movq %rax, 0xc439ac(%rip)    # 0xe280e0
jmp 0x1e4736
jmp 0x1e4738
movq 0xc439a1(%rip), %rax    # 0xe280e0
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_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e47ae
leaq 0x93d13b(%rip), %rax    # 0xb218e0
movq %rax, 0xc4393c(%rip)    # 0xe280e8
jmp 0x1e47f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e47ca
leaq 0x59717f(%rip), %rax    # 0x77b940
movq %rax, 0xc43920(%rip)    # 0xe280e8
jmp 0x1e47f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e47e6
leaq 0x2b4f13(%rip), %rax    # 0x4996f0
movq %rax, 0xc43904(%rip)    # 0xe280e8
jmp 0x1e47f4
leaq 0xb2ae3(%rip), %rax     # 0x2972d0
movq %rax, 0xc438f4(%rip)    # 0xe280e8
jmp 0x1e47f6
jmp 0x1e47f8
movq 0xc438e9(%rip), %rax    # 0xe280e8
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_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e486e
leaq 0x943aab(%rip), %rax    # 0xb28310
movq %rax, 0xc43884(%rip)    # 0xe280f0
jmp 0x1e48b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e488a
leaq 0x59c56f(%rip), %rax    # 0x780df0
movq %rax, 0xc43868(%rip)    # 0xe280f0
jmp 0x1e48b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e48a6
leaq 0x2ba413(%rip), %rax    # 0x49ecb0
movq %rax, 0xc4384c(%rip)    # 0xe280f0
jmp 0x1e48b4
leaq 0xb2a23(%rip), %rax     # 0x2972d0
movq %rax, 0xc4383c(%rip)    # 0xe280f0
jmp 0x1e48b6
jmp 0x1e48b8
movq 0xc43831(%rip), %rax    # 0xe280f0
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_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e492e
leaq 0x94bedb(%rip), %rax    # 0xb30800
movq %rax, 0xc437cc(%rip)    # 0xe280f8
jmp 0x1e4978
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e494a
leaq 0x5a250f(%rip), %rax    # 0x786e50
movq %rax, 0xc437b0(%rip)    # 0xe280f8
jmp 0x1e4976
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4966
leaq 0x2c06c3(%rip), %rax    # 0x4a5020
movq %rax, 0xc43794(%rip)    # 0xe280f8
jmp 0x1e4974
leaq 0xb2963(%rip), %rax     # 0x2972d0
movq %rax, 0xc43784(%rip)    # 0xe280f8
jmp 0x1e4976
jmp 0x1e4978
movq 0xc43779(%rip), %rax    # 0xe280f8
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_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e49ee
leaq 0x9030fb(%rip), %rax    # 0xae7ae0
movq %rax, 0xc43714(%rip)    # 0xe28100
jmp 0x1e4a38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4a0a
leaq 0x57164f(%rip), %rax    # 0x756050
movq %rax, 0xc436f8(%rip)    # 0xe28100
jmp 0x1e4a36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4a26
leaq 0x28e213(%rip), %rax    # 0x472c30
movq %rax, 0xc436dc(%rip)    # 0xe28100
jmp 0x1e4a34
leaq 0xb28a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc436cc(%rip)    # 0xe28100
jmp 0x1e4a36
jmp 0x1e4a38
movq 0xc436c1(%rip), %rax    # 0xe28100
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_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e4aae
leaq 0x90bdeb(%rip), %rax    # 0xaf0890
movq %rax, 0xc4365c(%rip)    # 0xe28108
jmp 0x1e4af8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4aca
leaq 0x57782f(%rip), %rax    # 0x75c2f0
movq %rax, 0xc43640(%rip)    # 0xe28108
jmp 0x1e4af6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4ae6
leaq 0x294723(%rip), %rax    # 0x479200
movq %rax, 0xc43624(%rip)    # 0xe28108
jmp 0x1e4af4
leaq 0xb27e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc43614(%rip)    # 0xe28108
jmp 0x1e4af6
jmp 0x1e4af8
movq 0xc43609(%rip), %rax    # 0xe28108
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_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e4b6e
leaq 0x91865b(%rip), %rax    # 0xafd1c0
movq %rax, 0xc435a4(%rip)    # 0xe28110
jmp 0x1e4bb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4b8a
leaq 0x57f54f(%rip), %rax    # 0x7640d0
movq %rax, 0xc43588(%rip)    # 0xe28110
jmp 0x1e4bb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4ba6
leaq 0x29c6b3(%rip), %rax    # 0x481250
movq %rax, 0xc4356c(%rip)    # 0xe28110
jmp 0x1e4bb4
leaq 0xb2723(%rip), %rax     # 0x2972d0
movq %rax, 0xc4355c(%rip)    # 0xe28110
jmp 0x1e4bb6
jmp 0x1e4bb8
movq 0xc43551(%rip), %rax    # 0xe28110
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_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e4c2e
leaq 0x92c0ab(%rip), %rax    # 0xb10cd0
movq %rax, 0xc434ec(%rip)    # 0xe28118
jmp 0x1e4c78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4c4a
leaq 0x58a6ef(%rip), %rax    # 0x76f330
movq %rax, 0xc434d0(%rip)    # 0xe28118
jmp 0x1e4c76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4c66
leaq 0x2a7ef3(%rip), %rax    # 0x48cb50
movq %rax, 0xc434b4(%rip)    # 0xe28118
jmp 0x1e4c74
leaq 0xb2663(%rip), %rax     # 0x2972d0
movq %rax, 0xc434a4(%rip)    # 0xe28118
jmp 0x1e4c76
jmp 0x1e4c78
movq 0xc43499(%rip), %rax    # 0xe28118
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_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e4cee
leaq 0x957d9b(%rip), %rax    # 0xb3ca80
movq %rax, 0xc43434(%rip)    # 0xe28120
jmp 0x1e4d38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4d0a
leaq 0x5ad78f(%rip), %rax    # 0x792490
movq %rax, 0xc43418(%rip)    # 0xe28120
jmp 0x1e4d36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4d26
leaq 0x2c9693(%rip), %rax    # 0x4ae3b0
movq %rax, 0xc433fc(%rip)    # 0xe28120
jmp 0x1e4d34
leaq 0xb4503(%rip), %rax     # 0x299230
movq %rax, 0xc433ec(%rip)    # 0xe28120
jmp 0x1e4d36
jmp 0x1e4d38
movq 0xc433e1(%rip), %rax    # 0xe28120
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_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e4dae
leaq 0x965e0b(%rip), %rax    # 0xb4abb0
movq %rax, 0xc4337c(%rip)    # 0xe28128
jmp 0x1e4df8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4dca
leaq 0x5b8c4f(%rip), %rax    # 0x79da10
movq %rax, 0xc43360(%rip)    # 0xe28128
jmp 0x1e4df6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4de6
leaq 0x2d3f33(%rip), %rax    # 0x4b8d10
movq %rax, 0xc43344(%rip)    # 0xe28128
jmp 0x1e4df4
leaq 0xb4443(%rip), %rax     # 0x299230
movq %rax, 0xc43334(%rip)    # 0xe28128
jmp 0x1e4df6
jmp 0x1e4df8
movq 0xc43329(%rip), %rax    # 0xe28128
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_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e4e6e
leaq 0x97581b(%rip), %rax    # 0xb5a680
movq %rax, 0xc432c4(%rip)    # 0xe28130
jmp 0x1e4eb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4e8a
leaq 0x5c49bf(%rip), %rax    # 0x7a9840
movq %rax, 0xc432a8(%rip)    # 0xe28130
jmp 0x1e4eb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4ea6
leaq 0x2def43(%rip), %rax    # 0x4c3de0
movq %rax, 0xc4328c(%rip)    # 0xe28130
jmp 0x1e4eb4
leaq 0xb4383(%rip), %rax     # 0x299230
movq %rax, 0xc4327c(%rip)    # 0xe28130
jmp 0x1e4eb6
jmp 0x1e4eb8
movq 0xc43271(%rip), %rax    # 0xe28130
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_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1e4f2e
leaq 0x98815b(%rip), %rax    # 0xb6d080
movq %rax, 0xc4320c(%rip)    # 0xe28138
jmp 0x1e4f78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e4f4a
leaq 0x5d154f(%rip), %rax    # 0x7b6490
movq %rax, 0xc431f0(%rip)    # 0xe28138
jmp 0x1e4f76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4f66
leaq 0x2eaf33(%rip), %rax    # 0x4cfe90
movq %rax, 0xc431d4(%rip)    # 0xe28138
jmp 0x1e4f74
leaq 0xb42c3(%rip), %rax     # 0x299230
movq %rax, 0xc431c4(%rip)    # 0xe28138
jmp 0x1e4f76
jmp 0x1e4f78
movq 0xc431b9(%rip), %rax    # 0xe28138
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)