LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_scan_64_pointer = parasail_sg_qb_de_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_scan_64_pointer = parasail_sg_qb_de_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_scan_64_pointer = parasail_sg_qb_de_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_scan_64_pointer = parasail_sg_qb_de_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_scan_64_pointer = parasail_sg_qb_de_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_scan_64_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_trace_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 0x1db131
leaq 0x36c2bd(%rip), %rax    # 0x5473ec
jmp 0x1db160
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db145
leaq 0x25ce96(%rip), %rax    # 0x437fd9
jmp 0x1db160
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db159
leaq 0x62801(%rip), %rax     # 0x23d958
jmp 0x1db160
leaq 0x16743b(%rip), %rax    # 0x34259b
movq %rax, 0x562a59(%rip)    # 0x73dbc0
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_scan_32_pointer = parasail_sg_qb_de_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_scan_32_pointer = parasail_sg_qb_de_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_scan_32_pointer = parasail_sg_qb_de_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_scan_32_pointer = parasail_sg_qb_de_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_scan_32_pointer = parasail_sg_qb_de_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_scan_32_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_trace_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 0x1db1ba
leaq 0x36e183(%rip), %rax    # 0x54933b
jmp 0x1db1e9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db1ce
leaq 0x25ed27(%rip), %rax    # 0x439ef3
jmp 0x1db1e9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db1e2
leaq 0x62778(%rip), %rax     # 0x23d958
jmp 0x1db1e9
leaq 0x1697ab(%rip), %rax    # 0x344994
movq %rax, 0x5629d8(%rip)    # 0x73dbc8
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_scan_16_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_trace_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 0x1db243
leaq 0x36ff0b(%rip), %rax    # 0x54b14c
jmp 0x1db272
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db257
leaq 0x260b41(%rip), %rax    # 0x43bd96
jmp 0x1db272
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db26b
leaq 0x626ef(%rip), %rax     # 0x23d958
jmp 0x1db272
leaq 0x16b72d(%rip), %rax    # 0x34699f
movq %rax, 0x562957(%rip)    # 0x73dbd0
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_scan_8_pointer = parasail_sg_qb_de_scan;
    }
    return parasail_sg_qb_de_trace_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 0x1db2cc
leaq 0x371c6f(%rip), %rax    # 0x54cf39
jmp 0x1db2fb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db2e0
leaq 0x262954(%rip), %rax    # 0x43dc32
jmp 0x1db2fb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db2f4
leaq 0x62666(%rip), %rax     # 0x23d958
jmp 0x1db2fb
leaq 0x16d83f(%rip), %rax    # 0x348b3a
movq %rax, 0x5628d6(%rip)    # 0x73dbd8
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db355
leaq 0x383f27(%rip), %rax    # 0x55f27a
jmp 0x1db384
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db369
leaq 0x2704a6(%rip), %rax    # 0x44b80d
jmp 0x1db384
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db37d
leaq 0x6156f(%rip), %rax     # 0x23c8ea
jmp 0x1db384
leaq 0x17cda0(%rip), %rax    # 0x358124
movq %rax, 0x562855(%rip)    # 0x73dbe0
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db3de
leaq 0x386676(%rip), %rax    # 0x561a52
jmp 0x1db40d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db3f2
leaq 0x272ba1(%rip), %rax    # 0x44df91
jmp 0x1db40d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db406
leaq 0x614e6(%rip), %rax     # 0x23c8ea
jmp 0x1db40d
leaq 0x17fb43(%rip), %rax    # 0x35af50
movq %rax, 0x5627d4(%rip)    # 0x73dbe8
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db467
leaq 0x388b55(%rip), %rax    # 0x563fba
jmp 0x1db496
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db47b
leaq 0x27506d(%rip), %rax    # 0x4504e6
jmp 0x1db496
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db48f
leaq 0x6145d(%rip), %rax     # 0x23c8ea
jmp 0x1db496
leaq 0x1821b3(%rip), %rax    # 0x35d649
movq %rax, 0x562753(%rip)    # 0x73dbf0
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_striped_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db4f0
leaq 0x38b020(%rip), %rax    # 0x56650e
jmp 0x1db51f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db504
leaq 0x277570(%rip), %rax    # 0x452a72
jmp 0x1db51f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db518
leaq 0x613d4(%rip), %rax     # 0x23c8ea
jmp 0x1db51f
leaq 0x184a5f(%rip), %rax    # 0x35ff7e
movq %rax, 0x5626d2(%rip)    # 0x73dbf8
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_64_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db579
leaq 0x373f28(%rip), %rax    # 0x54f49f
jmp 0x1db5a8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db58d
leaq 0x2649b0(%rip), %rax    # 0x43ff3b
jmp 0x1db5a8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db5a1
leaq 0x6134b(%rip), %rax     # 0x23c8ea
jmp 0x1db5a8
leaq 0x16feef(%rip), %rax    # 0x34b497
movq %rax, 0x562651(%rip)    # 0x73dc00
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_32_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db602
leaq 0x3768b4(%rip), %rax    # 0x551eb4
jmp 0x1db631
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db616
leaq 0x266aa2(%rip), %rax    # 0x4420b6
jmp 0x1db631
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db62a
leaq 0x612c2(%rip), %rax     # 0x23c8ea
jmp 0x1db631
leaq 0x1723e1(%rip), %rax    # 0x34da12
movq %rax, 0x5625d0(%rip)    # 0x73dc08
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_16_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db68b
leaq 0x37a1c1(%rip), %rax    # 0x55584a
jmp 0x1db6ba
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db69f
leaq 0x2692b1(%rip), %rax    # 0x44494e
jmp 0x1db6ba
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db6b3
leaq 0x61239(%rip), %rax     # 0x23c8ea
jmp 0x1db6ba
leaq 0x174d50(%rip), %rax    # 0x35040a
movq %rax, 0x56254f(%rip)    # 0x73dc10
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_de_dispatch.c
// Function: parasail_sg_qb_de_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_de_trace_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_de_trace_diag_8_pointer = parasail_sg_qb_de;
    }
    return parasail_sg_qb_de_trace_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 0x1db714
leaq 0x37fa3f(%rip), %rax    # 0x55b151
jmp 0x1db743
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db728
leaq 0x26cc1f(%rip), %rax    # 0x448345
jmp 0x1db743
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1db73c
leaq 0x611b0(%rip), %rax     # 0x23c8ea
jmp 0x1db743
leaq 0x178baf(%rip), %rax    # 0x3542f2
movq %rax, 0x5624ce(%rip)    # 0x73dc18
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_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_64_pointer = parasail_sg_qb_de_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1db796
leaq 0x2797cd(%rip), %rax    # 0x454f61
jmp 0x1db7bc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db7aa
leaq 0x186adc(%rip), %rax    # 0x362284
jmp 0x1db7bc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1db7db
leaq 0x75a57(%rip), %rax     # 0x251213
movq %rax, 0x56245d(%rip)    # 0x73dc20
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_32_pointer = parasail_sg_qb_de_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1db810
leaq 0x27b3c8(%rip), %rax    # 0x456bd6
jmp 0x1db836
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db824
leaq 0x1885f7(%rip), %rax    # 0x363e19
jmp 0x1db836
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1db855
leaq 0x779ec(%rip), %rax     # 0x253222
movq %rax, 0x5623eb(%rip)    # 0x73dc28
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_16_pointer = parasail_sg_qb_de_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1db88a
leaq 0x27ceca(%rip), %rax    # 0x458752
jmp 0x1db8b0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db89e
leaq 0x18a108(%rip), %rax    # 0x3659a4
jmp 0x1db8b0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1db8cf
leaq 0x7966e(%rip), %rax     # 0x254f1e
movq %rax, 0x562379(%rip)    # 0x73dc30
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_de_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_scan_profile_8_pointer = parasail_sg_qb_de_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1db904
leaq 0x27e9bd(%rip), %rax    # 0x45a2bf
jmp 0x1db92a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db918
leaq 0x18bc22(%rip), %rax    # 0x367538
jmp 0x1db92a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1db949
leaq 0x7b485(%rip), %rax     # 0x256daf
movq %rax, 0x562307(%rip)    # 0x73dc38
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_de_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_64_pointer = parasail_sg_qb_de_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1db97e
leaq 0x28a5a7(%rip), %rax    # 0x465f23
jmp 0x1db9a4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1db992
leaq 0x195855(%rip), %rax    # 0x3711e5
jmp 0x1db9a4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1db9c3
leaq 0x86d8f(%rip), %rax     # 0x262733
movq %rax, 0x562295(%rip)    # 0x73dc40
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_de_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_32_pointer = parasail_sg_qb_de_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1db9f8
leaq 0x28bfa7(%rip), %rax    # 0x46799d
jmp 0x1dba1e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1dba0c
leaq 0x1971ca(%rip), %rax    # 0x372bd4
jmp 0x1dba1e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1dba3d
leaq 0x88b6b(%rip), %rax     # 0x264589
movq %rax, 0x562223(%rip)    # 0x73dc48
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_de_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_16_pointer = parasail_sg_qb_de_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1dba72
leaq 0x28d8c3(%rip), %rax    # 0x469333
jmp 0x1dba98
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1dba86
leaq 0x198abd(%rip), %rax    # 0x374541
jmp 0x1dba98
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1dbab7
leaq 0x8a55c(%rip), %rax     # 0x265ff4
movq %rax, 0x5621b1(%rip)    # 0x73dc50
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_de_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_striped_profile_8_pointer = parasail_sg_qb_de_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1dbaec
leaq 0x28f1d5(%rip), %rax    # 0x46acbf
jmp 0x1dbb12
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1dbb00
leaq 0x19a3a0(%rip), %rax    # 0x375e9e
jmp 0x1dbb12
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1dbb31
leaq 0x8c146(%rip), %rax     # 0x267c58
movq %rax, 0x56213f(%rip)    # 0x73dc58
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_profile_64_pointer = parasail_sg_qb_de_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_stats_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1dbb66
leaq 0x29279e(%rip), %rax    # 0x46e302
jmp 0x1dbb8c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1dbb7a
leaq 0x19ddd5(%rip), %rax    # 0x37994d
jmp 0x1dbb8c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1dbbab
leaq 0x8fe7e(%rip), %rax     # 0x26ba0a
movq %rax, 0x5620cd(%rip)    # 0x73dc60
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_de_dispatch.c
// Function: parasail_sg_qb_de_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_de_stats_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_de_stats_scan_profile_32_pointer = parasail_sg_qb_de_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_de_stats_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1dbbe0
leaq 0x295ecd(%rip), %rax    # 0x471aab
jmp 0x1dbc06
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1dbbf4
leaq 0x1a1406(%rip), %rax    # 0x37cff8
jmp 0x1dbc06
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1dbc25
leaq 0x93de5(%rip), %rax     # 0x26f9eb
movq %rax, 0x56205b(%rip)    # 0x73dc68
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq