LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_32_pointer = parasail_sg_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_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 0x1b6c58
leaq 0x3aafb9(%rip), %rax    # 0x561c0f
jmp 0x1b6c7e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b6c6c
leaq 0x2974e4(%rip), %rax    # 0x44e14e
jmp 0x1b6c7e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b6c9d
leaq 0x1a448f(%rip), %rax    # 0x35b10d
movq %rax, 0x584e43(%rip)    # 0x73bac8
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_dispatch.c
// Function: parasail_sg_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_16_pointer = parasail_sg_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_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 0x1b6cd2
leaq 0x3ad4a7(%rip), %rax    # 0x564177
jmp 0x1b6cf8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b6ce6
leaq 0x2999bf(%rip), %rax    # 0x4506a3
jmp 0x1b6cf8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b6d17
leaq 0x1a6b0e(%rip), %rax    # 0x35d806
movq %rax, 0x584dd1(%rip)    # 0x73bad0
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_dispatch.c
// Function: parasail_sg_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_trace_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_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_trace_striped_profile_8_pointer = parasail_sg_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_trace_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 0x1b6d4c
leaq 0x3af981(%rip), %rax    # 0x5666cb
jmp 0x1b6d72
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b6d60
leaq 0x29bed1(%rip), %rax    # 0x452c2f
jmp 0x1b6d72
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b6d91
leaq 0x1a93c9(%rip), %rax    # 0x36013b
movq %rax, 0x584d5f(%rip)    # 0x73bad8
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/sw_dispatch.c
// Function: parasail_sw_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_64_pointer = parasail_sw_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_64_pointer = parasail_sw_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b72b9
leaq 0x29dd39(%rip), %rax    # 0x454ff0
jmp 0x1b72e8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b72cd
leaq 0x1ab049(%rip), %rax    # 0x362314
jmp 0x1b72e8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b72e1
leaq 0x86709(%rip), %rax     # 0x23d9e8
jmp 0x1b72e8
leaq 0x99fbc(%rip), %rax     # 0x2512a4
movq %rax, 0x5847f1(%rip)    # 0x73bae0
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/sw_dispatch.c
// Function: parasail_sw_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_32_pointer = parasail_sw_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_32_pointer = parasail_sw_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b7342
leaq 0x29f924(%rip), %rax    # 0x456c64
jmp 0x1b7371
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7356
leaq 0x1acb54(%rip), %rax    # 0x363ea8
jmp 0x1b7371
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b736a
leaq 0x86680(%rip), %rax     # 0x23d9e8
jmp 0x1b7371
leaq 0x9bf3f(%rip), %rax     # 0x2532b0
movq %rax, 0x584770(%rip)    # 0x73bae8
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/sw_dispatch.c
// Function: parasail_sw_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_16_pointer = parasail_sw_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_16_pointer = parasail_sw_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b73cb
leaq 0x2a1417(%rip), %rax    # 0x4587e0
jmp 0x1b73fa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b73df
leaq 0x1ae657(%rip), %rax    # 0x365a34
jmp 0x1b73fa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b73f3
leaq 0x865f7(%rip), %rax     # 0x23d9e8
jmp 0x1b73fa
leaq 0x9dbb2(%rip), %rax     # 0x254fac
movq %rax, 0x5846ef(%rip)    # 0x73baf0
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/sw_dispatch.c
// Function: parasail_sw_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_8_pointer = parasail_sw_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_8_pointer = parasail_sw_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b7454
leaq 0x2a2efe(%rip), %rax    # 0x45a350
jmp 0x1b7483
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7468
leaq 0x1b0162(%rip), %rax    # 0x3675c8
jmp 0x1b7483
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b747c
leaq 0x8656e(%rip), %rax     # 0x23d9e8
jmp 0x1b7483
leaq 0x9f9bd(%rip), %rax     # 0x256e40
movq %rax, 0x58466e(%rip)    # 0x73baf8
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/sw_dispatch.c
// Function: parasail_sw_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_64_pointer = parasail_sw_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_64_pointer = parasail_sw_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b74dd
leaq 0x2aead9(%rip), %rax    # 0x465fb4
jmp 0x1b750c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b74f1
leaq 0x1b9d85(%rip), %rax    # 0x371274
jmp 0x1b750c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7505
leaq 0x85479(%rip), %rax     # 0x23c97c
jmp 0x1b750c
leaq 0xab2b8(%rip), %rax     # 0x2627c4
movq %rax, 0x5845ed(%rip)    # 0x73bb00
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/sw_dispatch.c
// Function: parasail_sw_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_32_pointer = parasail_sw_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_32_pointer = parasail_sw_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7566
leaq 0x2b04c8(%rip), %rax    # 0x467a2c
jmp 0x1b7595
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b757a
leaq 0x1bb6ec(%rip), %rax    # 0x372c64
jmp 0x1b7595
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b758e
leaq 0x853f0(%rip), %rax     # 0x23c97c
jmp 0x1b7595
leaq 0xad083(%rip), %rax     # 0x264618
movq %rax, 0x58456c(%rip)    # 0x73bb08
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/sw_dispatch.c
// Function: parasail_sw_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_16_pointer = parasail_sw_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_16_pointer = parasail_sw_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b75ef
leaq 0x2b1dd7(%rip), %rax    # 0x4693c4
jmp 0x1b761e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7603
leaq 0x1bcfcf(%rip), %rax    # 0x3745d0
jmp 0x1b761e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7617
leaq 0x85367(%rip), %rax     # 0x23c97c
jmp 0x1b761e
leaq 0xaea66(%rip), %rax     # 0x266084
movq %rax, 0x5844eb(%rip)    # 0x73bb10
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/sw_dispatch.c
// Function: parasail_sw_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_8_pointer = parasail_sw_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_8_pointer = parasail_sw_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7678
leaq 0x2b36da(%rip), %rax    # 0x46ad50
jmp 0x1b76a7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b768c
leaq 0x1be8a2(%rip), %rax    # 0x375f2c
jmp 0x1b76a7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b76a0
leaq 0x852de(%rip), %rax     # 0x23c97c
jmp 0x1b76a7
leaq 0xb0641(%rip), %rax     # 0x267ce8
movq %rax, 0x58446a(%rip)    # 0x73bb18
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/sw_dispatch.c
// Function: parasail_sw_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_64_pointer = parasail_sw_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_64_pointer = parasail_sw_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7701
leaq 0x2a4b81(%rip), %rax    # 0x45c280
jmp 0x1b7730
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7715
leaq 0x1b1b11(%rip), %rax    # 0x369224
jmp 0x1b7730
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7729
leaq 0x85255(%rip), %rax     # 0x23c97c
jmp 0x1b7730
leaq 0xa1a1c(%rip), %rax     # 0x25914c
movq %rax, 0x5843e9(%rip)    # 0x73bb20
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/sw_dispatch.c
// Function: parasail_sw_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_32_pointer = parasail_sw_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_32_pointer = parasail_sw_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b778a
leaq 0x2a6a8c(%rip), %rax    # 0x45e214
jmp 0x1b77b9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b779e
leaq 0x1b35f0(%rip), %rax    # 0x36ad8c
jmp 0x1b77b9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b77b2
leaq 0x851cc(%rip), %rax     # 0x23c97c
jmp 0x1b77b9
leaq 0xa3957(%rip), %rax     # 0x25b110
movq %rax, 0x584368(%rip)    # 0x73bb28
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/sw_dispatch.c
// Function: parasail_sw_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_16_pointer = parasail_sw_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_16_pointer = parasail_sw_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7813
leaq 0x2a8f6b(%rip), %rax    # 0x46077c
jmp 0x1b7842
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7827
leaq 0x1b524f(%rip), %rax    # 0x36ca74
jmp 0x1b7842
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b783b
leaq 0x85143(%rip), %rax     # 0x23c97c
jmp 0x1b7842
leaq 0xa58d6(%rip), %rax     # 0x25d118
movq %rax, 0x5842e7(%rip)    # 0x73bb30
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/sw_dispatch.c
// Function: parasail_sw_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_diag_8_pointer = parasail_sw_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_diag_8_pointer = parasail_sw_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b789c
leaq 0x2abf76(%rip), %rax    # 0x463810
jmp 0x1b78cb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b78b0
leaq 0x1b7632(%rip), %rax    # 0x36eee0
jmp 0x1b78cb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b78c4
leaq 0x850ba(%rip), %rax     # 0x23c97c
jmp 0x1b78cb
leaq 0xa8481(%rip), %rax     # 0x25fd4c
movq %rax, 0x584266(%rip)    # 0x73bb38
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_64_pointer = parasail_sw_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_64_pointer = parasail_sw_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b7925
leaq 0x2b6a6d(%rip), %rax    # 0x46e390
jmp 0x1b7954
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7939
leaq 0x1c20a5(%rip), %rax    # 0x3799dc
jmp 0x1b7954
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b794d
leaq 0x8609d(%rip), %rax     # 0x23d9e8
jmp 0x1b7954
leaq 0xb4144(%rip), %rax     # 0x26ba98
movq %rax, 0x5841e5(%rip)    # 0x73bb40
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_32_pointer = parasail_sw_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_32_pointer = parasail_sw_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b79ae
leaq 0x2ba190(%rip), %rax    # 0x471b3c
jmp 0x1b79dd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b79c2
leaq 0x1c56c8(%rip), %rax    # 0x37d088
jmp 0x1b79dd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b79d6
leaq 0x86014(%rip), %rax     # 0x23d9e8
jmp 0x1b79dd
leaq 0xb809f(%rip), %rax     # 0x26fa7c
movq %rax, 0x584164(%rip)    # 0x73bb48
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_16_pointer = parasail_sw_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_16_pointer = parasail_sw_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b7a37
leaq 0x2bd437(%rip), %rax    # 0x474e6c
jmp 0x1b7a66
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7a4b
leaq 0x1c898b(%rip), %rax    # 0x3803d4
jmp 0x1b7a66
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7a5f
leaq 0x85f8b(%rip), %rax     # 0x23d9e8
jmp 0x1b7a66
leaq 0xbb7e6(%rip), %rax     # 0x27324c
movq %rax, 0x5840e3(%rip)    # 0x73bb50
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/sw_dispatch.c
// Function: parasail_sw_stats_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_8_pointer = parasail_sw_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_8_pointer = parasail_sw_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_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 0x1b7ac0
leaq 0x2c06e2(%rip), %rax    # 0x4781a0
jmp 0x1b7aef
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7ad4
leaq 0x1cbcae(%rip), %rax    # 0x383780
jmp 0x1b7aef
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7ae8
leaq 0x85f02(%rip), %rax     # 0x23d9e8
jmp 0x1b7aef
leaq 0xbf0bd(%rip), %rax     # 0x276bac
movq %rax, 0x584062(%rip)    # 0x73bb58
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_64_pointer = parasail_sw_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_64_pointer = parasail_sw_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7b49
leaq 0x2d469d(%rip), %rax    # 0x48c1e4
jmp 0x1b7b78
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7b5d
leaq 0x1dde8d(%rip), %rax    # 0x3959e8
jmp 0x1b7b78
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7b71
leaq 0x84e0d(%rip), %rax     # 0x23c97c
jmp 0x1b7b78
leaq 0xd4234(%rip), %rax     # 0x28bdac
movq %rax, 0x583fe1(%rip)    # 0x73bb60
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_32_pointer = parasail_sw_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_32_pointer = parasail_sw_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7bd2
leaq 0x2d7a30(%rip), %rax    # 0x48f600
jmp 0x1b7c01
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7be6
leaq 0x1e12e4(%rip), %rax    # 0x398ec8
jmp 0x1b7c01
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7bfa
leaq 0x84d84(%rip), %rax     # 0x23c97c
jmp 0x1b7c01
leaq 0xd7eef(%rip), %rax     # 0x28faf0
movq %rax, 0x583f60(%rip)    # 0x73bb68
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_16_pointer = parasail_sw_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_16_pointer = parasail_sw_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7c5b
leaq 0x2daae3(%rip), %rax    # 0x49273c
jmp 0x1b7c8a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7c6f
leaq 0x1e44e7(%rip), %rax    # 0x39c154
jmp 0x1b7c8a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7c83
leaq 0x84cfb(%rip), %rax     # 0x23c97c
jmp 0x1b7c8a
leaq 0xdb462(%rip), %rax     # 0x2930ec
movq %rax, 0x583edf(%rip)    # 0x73bb70
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/sw_dispatch.c
// Function: parasail_sw_stats_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_8_pointer = parasail_sw_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_8_pointer = parasail_sw_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x1b7ce4
leaq 0x2ddc86(%rip), %rax    # 0x495968
jmp 0x1b7d13
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7cf8
leaq 0x1e7736(%rip), %rax    # 0x39f42c
jmp 0x1b7d13
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7d0c
leaq 0x84c72(%rip), %rax     # 0x23c97c
jmp 0x1b7d13
leaq 0xdec19(%rip), %rax     # 0x29692c
movq %rax, 0x583e5e(%rip)    # 0x73bb78
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