LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_db_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_db_striped_32_pointer = parasail_sg_qb_db_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_striped_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2676
leaq 0x28521a(%rip), %rax    # 0x46788e
jmp 0x1e26a5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e268a
leaq 0x19043d(%rip), %rax    # 0x372ac5
jmp 0x1e26a5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e269e
leaq 0x5a288(%rip), %rax     # 0x23c924
jmp 0x1e26a5
leaq 0x81dd5(%rip), %rax     # 0x26447a
movq %rax, 0x55bbbc(%rip)    # 0x73e268
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_db_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_db_striped_16_pointer = parasail_sg_qb_db_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_striped_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e26ff
leaq 0x286b27(%rip), %rax    # 0x469224
jmp 0x1e272e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2713
leaq 0x191d21(%rip), %rax    # 0x374432
jmp 0x1e272e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2727
leaq 0x5a1ff(%rip), %rax     # 0x23c924
jmp 0x1e272e
leaq 0x837b7(%rip), %rax     # 0x265ee5
movq %rax, 0x55bb3b(%rip)    # 0x73e270
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_db_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_db_striped_8_pointer = parasail_sg_qb_db_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_striped_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2788
leaq 0x28842a(%rip), %rax    # 0x46abb0
jmp 0x1e27b7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e279c
leaq 0x1935f5(%rip), %rax    # 0x375d8f
jmp 0x1e27b7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e27b0
leaq 0x5a176(%rip), %rax     # 0x23c924
jmp 0x1e27b7
leaq 0x85392(%rip), %rax     # 0x267b49
movq %rax, 0x55baba(%rip)    # 0x73e278
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_db_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_db_diag_64_pointer = parasail_sg_qb_db_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2811
leaq 0x279a1b(%rip), %rax    # 0x45c22a
jmp 0x1e2840
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2825
leaq 0x1869ab(%rip), %rax    # 0x3691ce
jmp 0x1e2840
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2839
leaq 0x5a0ed(%rip), %rax     # 0x23c924
jmp 0x1e2840
leaq 0x768b6(%rip), %rax     # 0x2590f6
movq %rax, 0x55ba39(%rip)    # 0x73e280
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_db_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_db_diag_32_pointer = parasail_sg_qb_db_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e289a
leaq 0x27b924(%rip), %rax    # 0x45e1bc
jmp 0x1e28c9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e28ae
leaq 0x18848b(%rip), %rax    # 0x36ad37
jmp 0x1e28c9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e28c2
leaq 0x5a064(%rip), %rax     # 0x23c924
jmp 0x1e28c9
leaq 0x787f0(%rip), %rax     # 0x25b0b9
movq %rax, 0x55b9b8(%rip)    # 0x73e288
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_db_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_db_diag_16_pointer = parasail_sg_qb_db_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2923
leaq 0x27de04(%rip), %rax    # 0x460725
jmp 0x1e2952
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2937
leaq 0x18a0e9(%rip), %rax    # 0x36ca1e
jmp 0x1e2952
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e294b
leaq 0x59fdb(%rip), %rax     # 0x23c924
jmp 0x1e2952
leaq 0x7a770(%rip), %rax     # 0x25d0c2
movq %rax, 0x55b937(%rip)    # 0x73e290
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_db_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_db_diag_8_pointer = parasail_sg_qb_db_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_diag_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e29ac
leaq 0x280e11(%rip), %rax    # 0x4637bb
jmp 0x1e29db
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e29c0
leaq 0x18c4ca(%rip), %rax    # 0x36ee88
jmp 0x1e29db
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e29d4
leaq 0x59f52(%rip), %rax     # 0x23c924
jmp 0x1e29db
leaq 0x7d31c(%rip), %rax     # 0x25fcf7
movq %rax, 0x55b8b6(%rip)    # 0x73e298
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_64_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2a35
leaq 0x28b7c0(%rip), %rax    # 0x46e1f3
jmp 0x1e2a64
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2a49
leaq 0x196df7(%rip), %rax    # 0x37983e
jmp 0x1e2a64
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2a5d
leaq 0x5af37(%rip), %rax     # 0x23d992
jmp 0x1e2a64
leaq 0x88e97(%rip), %rax     # 0x26b8fb
movq %rax, 0x55b835(%rip)    # 0x73e2a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_32_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2abe
leaq 0x28eee0(%rip), %rax    # 0x47199c
jmp 0x1e2aed
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2ad2
leaq 0x19a419(%rip), %rax    # 0x37cee9
jmp 0x1e2aed
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2ae6
leaq 0x5aeae(%rip), %rax     # 0x23d992
jmp 0x1e2aed
leaq 0x8cdef(%rip), %rax     # 0x26f8dc
movq %rax, 0x55b7b4(%rip)    # 0x73e2a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_16_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2b47
leaq 0x292188(%rip), %rax    # 0x474ccd
jmp 0x1e2b76
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2b5b
leaq 0x19d6db(%rip), %rax    # 0x380234
jmp 0x1e2b76
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2b6f
leaq 0x5ae25(%rip), %rax     # 0x23d992
jmp 0x1e2b76
leaq 0x90537(%rip), %rax     # 0x2730ad
movq %rax, 0x55b733(%rip)    # 0x73e2b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_scan_8_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2bd0
leaq 0x295433(%rip), %rax    # 0x478001
jmp 0x1e2bff
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2be4
leaq 0x1a0a01(%rip), %rax    # 0x3835e3
jmp 0x1e2bff
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2bf8
leaq 0x5ad9c(%rip), %rax     # 0x23d992
jmp 0x1e2bff
leaq 0x93e0d(%rip), %rax     # 0x276a0c
movq %rax, 0x55b6b2(%rip)    # 0x73e2b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2c59
leaq 0x2a93ef(%rip), %rax    # 0x48c046
jmp 0x1e2c88
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2c6d
leaq 0x1b2bdd(%rip), %rax    # 0x395848
jmp 0x1e2c88
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2c81
leaq 0x59ca5(%rip), %rax     # 0x23c924
jmp 0x1e2c88
leaq 0xa8f86(%rip), %rax     # 0x28bc0e
movq %rax, 0x55b631(%rip)    # 0x73e2c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2ce2
leaq 0x2ac782(%rip), %rax    # 0x48f462
jmp 0x1e2d11
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2cf6
leaq 0x1b6037(%rip), %rax    # 0x398d2b
jmp 0x1e2d11
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2d0a
leaq 0x59c1c(%rip), %rax     # 0x23c924
jmp 0x1e2d11
leaq 0xacc3f(%rip), %rax     # 0x28f950
movq %rax, 0x55b5b0(%rip)    # 0x73e2c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2d6b
leaq 0x2af834(%rip), %rax    # 0x49259d
jmp 0x1e2d9a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2d7f
leaq 0x1b923a(%rip), %rax    # 0x39bfb7
jmp 0x1e2d9a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2d93
leaq 0x59b93(%rip), %rax     # 0x23c924
jmp 0x1e2d9a
leaq 0xb01b2(%rip), %rax     # 0x292f4c
movq %rax, 0x55b52f(%rip)    # 0x73e2d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_striped_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2df4
leaq 0x2b29d8(%rip), %rax    # 0x4957ca
jmp 0x1e2e23
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2e08
leaq 0x1bc489(%rip), %rax    # 0x39f28f
jmp 0x1e2e23
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2e1c
leaq 0x59b0a(%rip), %rax     # 0x23c924
jmp 0x1e2e23
leaq 0xb396b(%rip), %rax     # 0x29678e
movq %rax, 0x55b4ae(%rip)    # 0x73e2d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_64_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2e7d
leaq 0x298b2a(%rip), %rax    # 0x47b9a5
jmp 0x1e2eac
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2e91
leaq 0x1a4029(%rip), %rax    # 0x386eb8
jmp 0x1e2eac
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2ea5
leaq 0x59a81(%rip), %rax     # 0x23c924
jmp 0x1e2eac
leaq 0x97ec4(%rip), %rax     # 0x27ad70
movq %rax, 0x55b42d(%rip)    # 0x73e2e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_32_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2f06
leaq 0x29c1ea(%rip), %rax    # 0x47f0ee
jmp 0x1e2f35
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2f1a
leaq 0x1a751a(%rip), %rax    # 0x38a432
jmp 0x1e2f35
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2f2e
leaq 0x599f8(%rip), %rax     # 0x23c924
jmp 0x1e2f35
leaq 0x9bb31(%rip), %rax     # 0x27ea66
movq %rax, 0x55b3ac(%rip)    # 0x73e2e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_16_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e2f8f
leaq 0x2a00c6(%rip), %rax    # 0x483053
jmp 0x1e2fbe
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e2fa3
leaq 0x1aab80(%rip), %rax    # 0x38db21
jmp 0x1e2fbe
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e2fb7
leaq 0x5996f(%rip), %rax     # 0x23c924
jmp 0x1e2fbe
leaq 0x9f534(%rip), %rax     # 0x2824f2
movq %rax, 0x55b32b(%rip)    # 0x73e2f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_db_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_db_stats_diag_8_pointer = parasail_sg_qb_db;
    }
    return parasail_sg_qb_db_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e3018
leaq 0x2a4e69(%rip), %rax    # 0x487e7f
jmp 0x1e3047
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e302c
leaq 0x1aeab9(%rip), %rax    # 0x391ae3
jmp 0x1e3047
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e3040
leaq 0x598e6(%rip), %rax     # 0x23c924
jmp 0x1e3047
leaq 0xa405b(%rip), %rax     # 0x2870a2
movq %rax, 0x55b2aa(%rip)    # 0x73e2f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_db_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_scan_64_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e30a1
leaq 0x2b6770(%rip), %rax    # 0x49980f
jmp 0x1e30d0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e30b5
leaq 0x1be8fc(%rip), %rax    # 0x3a19af
jmp 0x1e30d0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e30c9
leaq 0x5a8cb(%rip), %rax     # 0x23d992
jmp 0x1e30d0
leaq 0xb7983(%rip), %rax     # 0x29aa53
movq %rax, 0x55b229(%rip)    # 0x73e300
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_db_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_scan_32_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e312a
leaq 0x2b866e(%rip), %rax    # 0x49b796
jmp 0x1e3159
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e313e
leaq 0x1c0546(%rip), %rax    # 0x3a3682
jmp 0x1e3159
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e3152
leaq 0x5a842(%rip), %rax     # 0x23d992
jmp 0x1e3159
leaq 0xb9a83(%rip), %rax     # 0x29cbdc
movq %rax, 0x55b1a8(%rip)    # 0x73e308
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_db_dispatch.c
// Function: parasail_sg_qb_db_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_db_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_db_table_scan_16_pointer = parasail_sg_qb_db_scan;
    }
    return parasail_sg_qb_db_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e31b3
leaq 0x2ba7d5(%rip), %rax    # 0x49d986
jmp 0x1e31e2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e31c7
leaq 0x1c237c(%rip), %rax    # 0x3a5541
jmp 0x1e31e2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e31db
leaq 0x5a7b9(%rip), %rax     # 0x23d992
jmp 0x1e31e2
leaq 0xbba02(%rip), %rax     # 0x29ebe4
movq %rax, 0x55b127(%rip)    # 0x73e310
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax