LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_64_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20ed42
leaq 0x32ff16(%rip), %rax    # 0x53ec56
jmp 0x20ed68
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ed56
leaq 0x22d3e2(%rip), %rax    # 0x43c136
jmp 0x20ed68
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20ed87
leaq 0x1439e2(%rip), %rax    # 0x35274a
movq %rax, 0x593891(%rip)    # 0x7a2600
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_32_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20edbc
leaq 0x3346b8(%rip), %rax    # 0x543472
jmp 0x20ede2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20edd0
leaq 0x230e54(%rip), %rax    # 0x43fc22
jmp 0x20ede2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20ee01
leaq 0x147b3c(%rip), %rax    # 0x35691e
movq %rax, 0x59381f(%rip)    # 0x7a2608
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_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_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_16_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x20ee36
leaq 0x337d52(%rip), %rax    # 0x546b86
jmp 0x20ee5c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ee4a
leaq 0x2341da(%rip), %rax    # 0x443022
jmp 0x20ee5c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20ee7b
leaq 0x14b5da(%rip), %rax    # 0x35a436
movq %rax, 0x5937ad(%rip)    # 0x7a2610
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_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_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_scan_profile_8_pointer = parasail_nw_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x20eeb0
leaq 0x33c1b4(%rip), %rax    # 0x54b062
jmp 0x20eed6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20eec4
leaq 0x237b7c(%rip), %rax    # 0x446a3e
jmp 0x20eed6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20eef5
leaq 0x14f2c0(%rip), %rax    # 0x35e196
movq %rax, 0x59373b(%rip)    # 0x7a2618
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_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_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_64_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x20ef2a
leaq 0x356ade(%rip), %rax    # 0x565a06
jmp 0x20ef50
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ef3e
leaq 0x24dbb6(%rip), %rax    # 0x45caf2
jmp 0x20ef50
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20ef6f
leaq 0x166ece(%rip), %rax    # 0x375e1e
movq %rax, 0x5936c9(%rip)    # 0x7a2620
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_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_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_32_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x20efa4
leaq 0x35ab5c(%rip), %rax    # 0x569afe
jmp 0x20efca
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20efb8
leaq 0x2513f4(%rip), %rax    # 0x4603aa
jmp 0x20efca
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20efe9
leaq 0x16ad20(%rip), %rax    # 0x379cea
movq %rax, 0x593657(%rip)    # 0x7a2628
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_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_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_16_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x20f01e
leaq 0x35de56(%rip), %rax    # 0x56ce72
jmp 0x20f044
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f032
leaq 0x25436a(%rip), %rax    # 0x46339a
jmp 0x20f044
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f063
leaq 0x16e3ee(%rip), %rax    # 0x37d432
movq %rax, 0x5935e5(%rip)    # 0x7a2630
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_stats_rowcol_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_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_rowcol_striped_profile_8_pointer = parasail_nw_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x20f098
leaq 0x361f70(%rip), %rax    # 0x571006
jmp 0x20f0be
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f0ac
leaq 0x257ac8(%rip), %rax    # 0x466b72
jmp 0x20f0be
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f0dd
leaq 0x171dc0(%rip), %rax    # 0x380e7e
movq %rax, 0x593573(%rip)    # 0x7a2638
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_trace_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_64_pointer = parasail_nw_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_trace_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20f112
leaq 0x365b1a(%rip), %rax    # 0x574c2a
jmp 0x20f138
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f126
leaq 0x25bc36(%rip), %rax    # 0x46ad5a
jmp 0x20f138
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f157
leaq 0x1764ea(%rip), %rax    # 0x385622
movq %rax, 0x593501(%rip)    # 0x7a2640
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_trace_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_32_pointer = parasail_nw_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_trace_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x20f18c
leaq 0x36860c(%rip), %rax    # 0x577796
jmp 0x20f1b2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f1a0
leaq 0x25db9c(%rip), %rax    # 0x46cd3a
jmp 0x20f1b2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f1d1
leaq 0x178658(%rip), %rax    # 0x38780a
movq %rax, 0x59348f(%rip)    # 0x7a2648
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_16_pointer = parasail_nw_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20f206
leaq 0x36a00a(%rip), %rax    # 0x57920e
jmp 0x20f22c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f21a
leaq 0x25f486(%rip), %rax    # 0x46e69e
jmp 0x20f22c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f24b
leaq 0x17a2ae(%rip), %rax    # 0x3894da
movq %rax, 0x59341d(%rip)    # 0x7a2650
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_scan_profile_8_pointer = parasail_nw_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20f280
leaq 0x36ba58(%rip), %rax    # 0x57acd6
jmp 0x20f2a6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f294
leaq 0x260e7c(%rip), %rax    # 0x47010e
jmp 0x20f2a6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f2c5
leaq 0x17bd20(%rip), %rax    # 0x38afc6
movq %rax, 0x5933ab(%rip)    # 0x7a2658
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_64_pointer = parasail_nw_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20f2fa
leaq 0x37c5ee(%rip), %rax    # 0x58b8e6
jmp 0x20f320
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f30e
leaq 0x26cc5e(%rip), %rax    # 0x47bf6a
jmp 0x20f320
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f33f
leaq 0x188fa2(%rip), %rax    # 0x3982c2
movq %rax, 0x593339(%rip)    # 0x7a2660
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_32_pointer = parasail_nw_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20f374
leaq 0x37f814(%rip), %rax    # 0x58eb86
jmp 0x20f39a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f388
leaq 0x26f75c(%rip), %rax    # 0x47eae2
jmp 0x20f39a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f3b9
leaq 0x18bec4(%rip), %rax    # 0x39b25e
movq %rax, 0x5932c7(%rip)    # 0x7a2668
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_16_pointer = parasail_nw_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20f3ee
leaq 0x38184a(%rip), %rax    # 0x590c36
jmp 0x20f414
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f402
leaq 0x271702(%rip), %rax    # 0x480b02
jmp 0x20f414
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f433
leaq 0x18e1de(%rip), %rax    # 0x39d5f2
movq %rax, 0x593255(%rip)    # 0x7a2670
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_O1/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_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_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_profile_8_pointer = parasail_nw_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x594f9c
testl %eax, %eax
je 0x20f468
leaq 0x383950(%rip), %rax    # 0x592db6
jmp 0x20f48e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f47c
leaq 0x2737ec(%rip), %rax    # 0x482c66
jmp 0x20f48e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x20f4ad
leaq 0x1902f8(%rip), %rax    # 0x39f786
movq %rax, 0x5931e3(%rip)    # 0x7a2678
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_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_64_dispatcher
parasail_result_t* parasail_sg_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_scan_64_pointer = parasail_sg_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_64_pointer = parasail_sg_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x594f9c
testl %eax, %eax
je 0x20f9d5
leaq 0x276c48(%rip), %rax    # 0x48661b
jmp 0x20fa04
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20f9e9
leaq 0x193429(%rip), %rax    # 0x3a2e10
jmp 0x20fa04
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20f9fd
leaq 0x8b057(%rip), %rax     # 0x29aa52
jmp 0x20fa04
leaq 0x9c601(%rip), %rax     # 0x2ac005
movq %rax, 0x592c75(%rip)    # 0x7a2680
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_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_32_dispatcher
parasail_result_t* parasail_sg_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_scan_32_pointer = parasail_sg_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_32_pointer = parasail_sg_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x594f9c
testl %eax, %eax
je 0x20fa5e
leaq 0x278705(%rip), %rax    # 0x488161
jmp 0x20fa8d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fa72
leaq 0x194bcb(%rip), %rax    # 0x3a463b
jmp 0x20fa8d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fa86
leaq 0x8afce(%rip), %rax     # 0x29aa52
jmp 0x20fa8d
leaq 0x9dfe0(%rip), %rax     # 0x2ada6d
movq %rax, 0x592bf4(%rip)    # 0x7a2688
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_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_16_dispatcher
parasail_result_t* parasail_sg_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_scan_16_pointer = parasail_sg_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_16_pointer = parasail_sg_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x594f9c
testl %eax, %eax
je 0x20fae7
leaq 0x279d6b(%rip), %rax    # 0x489850
jmp 0x20fb16
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fafb
leaq 0x196215(%rip), %rax    # 0x3a5d0e
jmp 0x20fb16
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fb0f
leaq 0x8af45(%rip), %rax     # 0x29aa52
jmp 0x20fb16
leaq 0x9f730(%rip), %rax     # 0x2af246
movq %rax, 0x592b73(%rip)    # 0x7a2690
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_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_8_dispatcher
parasail_result_t* parasail_sg_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_scan_8_pointer = parasail_sg_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x594f9c
testl %eax, %eax
je 0x20fb70
leaq 0x27b3a8(%rip), %rax    # 0x48af16
jmp 0x20fb9f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fb84
leaq 0x19784e(%rip), %rax    # 0x3a73d0
jmp 0x20fb9f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fb98
leaq 0x8aebc(%rip), %rax     # 0x29aa52
jmp 0x20fb9f
leaq 0xa1034(%rip), %rax     # 0x2b0bd3
movq %rax, 0x592af2(%rip)    # 0x7a2698
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_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_64_dispatcher
parasail_result_t* parasail_sg_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_striped_64_pointer = parasail_sg_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x594f9c
testl %eax, %eax
je 0x20fbf9
leaq 0x287a21(%rip), %rax    # 0x497618
jmp 0x20fc28
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fc0d
leaq 0x1a0e06(%rip), %rax    # 0x3b0a11
jmp 0x20fc28
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fc21
leaq 0x89fb5(%rip), %rax     # 0x299bd4
jmp 0x20fc28
leaq 0xab48b(%rip), %rax     # 0x2bb0b3
movq %rax, 0x592a71(%rip)    # 0x7a26a0
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_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_32_dispatcher
parasail_result_t* parasail_sg_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_striped_32_pointer = parasail_sg_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x594f9c
testl %eax, %eax
je 0x20fc82
leaq 0x289159(%rip), %rax    # 0x498dd9
jmp 0x20fcb1
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fc96
leaq 0x1a23b9(%rip), %rax    # 0x3b204d
jmp 0x20fcb1
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fcaa
leaq 0x89f2c(%rip), %rax     # 0x299bd4
jmp 0x20fcb1
leaq 0xacbce(%rip), %rax     # 0x2bc87f
movq %rax, 0x5929f0(%rip)    # 0x7a26a8
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