LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_profile_16_pointer = parasail_sg_de_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_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 0x1d364a
leaq 0x377c0b(%rip), %rax    # 0x54b253
jmp 0x1d3670
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d365e
leaq 0x268841(%rip), %rax    # 0x43be9d
jmp 0x1d3670
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d368f
leaq 0x173436(%rip), %rax    # 0x346aa6
movq %rax, 0x569e79(%rip)    # 0x73d4f0
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_de_dispatch.c
// Function: parasail_sg_de_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_scan_profile_8_pointer = parasail_sg_de_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_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 0x1d36c4
leaq 0x37997e(%rip), %rax    # 0x54d040
jmp 0x1d36ea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d36d8
leaq 0x26a663(%rip), %rax    # 0x43dd39
jmp 0x1d36ea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d3709
leaq 0x175557(%rip), %rax    # 0x348c41
movq %rax, 0x569e07(%rip)    # 0x73d4f8
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_de_trace_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_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_64_pointer = parasail_sg_de_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_trace_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 0x1d373e
leaq 0x38bc45(%rip), %rax    # 0x55f381
jmp 0x1d3764
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d3752
leaq 0x2781c4(%rip), %rax    # 0x44b914
jmp 0x1d3764
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d3783
leaq 0x184ac7(%rip), %rax    # 0x35822b
movq %rax, 0x569d95(%rip)    # 0x73d500
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_32_pointer = parasail_sg_de_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_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 0x1d37b8
leaq 0x38e3a3(%rip), %rax    # 0x561b59
jmp 0x1d37de
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d37cc
leaq 0x27a8ce(%rip), %rax    # 0x44e098
jmp 0x1d37de
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d37fd
leaq 0x187879(%rip), %rax    # 0x35b057
movq %rax, 0x569d23(%rip)    # 0x73d508
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_de_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_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_16_pointer = parasail_sg_de_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_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 0x1d3832
leaq 0x390891(%rip), %rax    # 0x5640c1
jmp 0x1d3858
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d3846
leaq 0x27cda9(%rip), %rax    # 0x4505ed
jmp 0x1d3858
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d3877
leaq 0x189ef8(%rip), %rax    # 0x35d750
movq %rax, 0x569cb1(%rip)    # 0x73d510
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_de_dispatch.c
// Function: parasail_sg_de_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_de_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_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_trace_striped_profile_8_pointer = parasail_sg_de_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_de_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 0x1d38ac
leaq 0x392d6b(%rip), %rax    # 0x566615
jmp 0x1d38d2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d38c0
leaq 0x27f2bb(%rip), %rax    # 0x452b79
jmp 0x1d38d2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1d38f1
leaq 0x18c7b3(%rip), %rax    # 0x360085
movq %rax, 0x569c3f(%rip)    # 0x73d518
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_dx_dispatch.c
// Function: parasail_sg_dx_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_scan_64_pointer = parasail_sg_dx_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d3e19
leaq 0x280fe4(%rip), %rax    # 0x454dfb
jmp 0x1d3e48
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d3e2d
leaq 0x18e2f3(%rip), %rax    # 0x36211e
jmp 0x1d3e48
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d3e41
leaq 0x69afc(%rip), %rax     # 0x23d93b
jmp 0x1d3e48
leaq 0x7d265(%rip), %rax     # 0x2510ad
movq %rax, 0x5696d1(%rip)    # 0x73d520
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_dx_dispatch.c
// Function: parasail_sg_dx_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_scan_32_pointer = parasail_sg_dx_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d3ea2
leaq 0x282bd0(%rip), %rax    # 0x456a70
jmp 0x1d3ed1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d3eb6
leaq 0x18fdff(%rip), %rax    # 0x363cb3
jmp 0x1d3ed1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d3eca
leaq 0x69a73(%rip), %rax     # 0x23d93b
jmp 0x1d3ed1
leaq 0x7f1eb(%rip), %rax     # 0x2530bc
movq %rax, 0x569650(%rip)    # 0x73d528
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_dx_dispatch.c
// Function: parasail_sg_dx_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_scan_16_pointer = parasail_sg_dx_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d3f2b
leaq 0x2846c3(%rip), %rax    # 0x4585ec
jmp 0x1d3f5a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d3f3f
leaq 0x191901(%rip), %rax    # 0x36583e
jmp 0x1d3f5a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d3f53
leaq 0x699ea(%rip), %rax     # 0x23d93b
jmp 0x1d3f5a
leaq 0x80e5e(%rip), %rax     # 0x254db8
movq %rax, 0x5695cf(%rip)    # 0x73d530
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_dx_dispatch.c
// Function: parasail_sg_dx_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_scan_8_pointer = parasail_sg_dx_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d3fb4
leaq 0x2861a7(%rip), %rax    # 0x45a159
jmp 0x1d3fe3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d3fc8
leaq 0x19340c(%rip), %rax    # 0x3673d2
jmp 0x1d3fe3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d3fdc
leaq 0x69961(%rip), %rax     # 0x23d93b
jmp 0x1d3fe3
leaq 0x82c66(%rip), %rax     # 0x256c49
movq %rax, 0x56954e(%rip)    # 0x73d538
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_dx_dispatch.c
// Function: parasail_sg_dx_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_striped_64_pointer = parasail_sg_dx_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d403d
leaq 0x291d82(%rip), %rax    # 0x465dbd
jmp 0x1d406c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4051
leaq 0x19d030(%rip), %rax    # 0x37107f
jmp 0x1d406c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4065
leaq 0x6886a(%rip), %rax     # 0x23c8cd
jmp 0x1d406c
leaq 0x8e561(%rip), %rax     # 0x2625cd
movq %rax, 0x5694cd(%rip)    # 0x73d540
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_dx_dispatch.c
// Function: parasail_sg_dx_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_striped_32_pointer = parasail_sg_dx_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d40c6
leaq 0x293773(%rip), %rax    # 0x467837
jmp 0x1d40f5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d40da
leaq 0x19e996(%rip), %rax    # 0x372a6e
jmp 0x1d40f5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d40ee
leaq 0x687e1(%rip), %rax     # 0x23c8cd
jmp 0x1d40f5
leaq 0x9032e(%rip), %rax     # 0x264423
movq %rax, 0x56944c(%rip)    # 0x73d548
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_dx_dispatch.c
// Function: parasail_sg_dx_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_striped_16_pointer = parasail_sg_dx_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d414f
leaq 0x295080(%rip), %rax    # 0x4691cd
jmp 0x1d417e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4163
leaq 0x1a027a(%rip), %rax    # 0x3743db
jmp 0x1d417e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4177
leaq 0x68758(%rip), %rax     # 0x23c8cd
jmp 0x1d417e
leaq 0x91d10(%rip), %rax     # 0x265e8e
movq %rax, 0x5693cb(%rip)    # 0x73d550
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_dx_dispatch.c
// Function: parasail_sg_dx_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_striped_8_pointer = parasail_sg_dx_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d41d8
leaq 0x296983(%rip), %rax    # 0x46ab59
jmp 0x1d4207
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d41ec
leaq 0x1a1b4e(%rip), %rax    # 0x375d38
jmp 0x1d4207
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4200
leaq 0x686cf(%rip), %rax     # 0x23c8cd
jmp 0x1d4207
leaq 0x938eb(%rip), %rax     # 0x267af2
movq %rax, 0x56934a(%rip)    # 0x73d558
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_dx_dispatch.c
// Function: parasail_sg_dx_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_diag_32_pointer = parasail_sg_dx_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d42ea
leaq 0x289e7d(%rip), %rax    # 0x45e165
jmp 0x1d4319
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d42fe
leaq 0x1969e4(%rip), %rax    # 0x36ace0
jmp 0x1d4319
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4312
leaq 0x685bd(%rip), %rax     # 0x23c8cd
jmp 0x1d4319
leaq 0x86d49(%rip), %rax     # 0x25b062
movq %rax, 0x569248(%rip)    # 0x73d568
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_dx_dispatch.c
// Function: parasail_sg_dx_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_diag_16_pointer = parasail_sg_dx_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d4373
leaq 0x28c35d(%rip), %rax    # 0x4606ce
jmp 0x1d43a2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4387
leaq 0x198642(%rip), %rax    # 0x36c9c7
jmp 0x1d43a2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d439b
leaq 0x68534(%rip), %rax     # 0x23c8cd
jmp 0x1d43a2
leaq 0x88cc9(%rip), %rax     # 0x25d06b
movq %rax, 0x5691c7(%rip)    # 0x73d570
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_dx_dispatch.c
// Function: parasail_sg_dx_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_diag_8_pointer = parasail_sg_dx_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d43fc
leaq 0x28f36a(%rip), %rax    # 0x463764
jmp 0x1d442b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4410
leaq 0x19aa23(%rip), %rax    # 0x36ee31
jmp 0x1d442b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4424
leaq 0x684ab(%rip), %rax     # 0x23c8cd
jmp 0x1d442b
leaq 0x8b875(%rip), %rax     # 0x25fca0
movq %rax, 0x569146(%rip)    # 0x73d578
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d4485
leaq 0x299d19(%rip), %rax    # 0x46e19c
jmp 0x1d44b4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4499
leaq 0x1a5350(%rip), %rax    # 0x3797e7
jmp 0x1d44b4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d44ad
leaq 0x69490(%rip), %rax     # 0x23d93b
jmp 0x1d44b4
leaq 0x973f0(%rip), %rax     # 0x26b8a4
movq %rax, 0x5690c5(%rip)    # 0x73d580
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d450e
leaq 0x29d439(%rip), %rax    # 0x471945
jmp 0x1d453d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4522
leaq 0x1a8972(%rip), %rax    # 0x37ce92
jmp 0x1d453d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4536
leaq 0x69407(%rip), %rax     # 0x23d93b
jmp 0x1d453d
leaq 0x9b348(%rip), %rax     # 0x26f885
movq %rax, 0x569044(%rip)    # 0x73d588
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d4597
leaq 0x2a06e1(%rip), %rax    # 0x474c76
jmp 0x1d45c6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d45ab
leaq 0x1abc34(%rip), %rax    # 0x3801dd
jmp 0x1d45c6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d45bf
leaq 0x6937e(%rip), %rax     # 0x23d93b
jmp 0x1d45c6
leaq 0x9ea90(%rip), %rax     # 0x273056
movq %rax, 0x568fc3(%rip)    # 0x73d590
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d4620
leaq 0x2a398c(%rip), %rax    # 0x477faa
jmp 0x1d464f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d4634
leaq 0x1aef5a(%rip), %rax    # 0x38358c
jmp 0x1d464f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d4648
leaq 0x692f5(%rip), %rax     # 0x23d93b
jmp 0x1d464f
leaq 0xa2366(%rip), %rax     # 0x2769b5
movq %rax, 0x568f42(%rip)    # 0x73d598
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d46a9
leaq 0x2b7948(%rip), %rax    # 0x48bfef
jmp 0x1d46d8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d46bd
leaq 0x1c1136(%rip), %rax    # 0x3957f1
jmp 0x1d46d8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d46d1
leaq 0x681fe(%rip), %rax     # 0x23c8cd
jmp 0x1d46d8
leaq 0xb74df(%rip), %rax     # 0x28bbb7
movq %rax, 0x568ec1(%rip)    # 0x73d5a0
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