LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_trace_striped_64_dispatcher
parasail_result_t* parasail_nw_trace_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_64_pointer = parasail_nw_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_trace_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_trace_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0245
leaq 0x3ad0d5(%rip), %rax    # 0x55d318
jmp 0x1b0274
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0259
leaq 0x2996b9(%rip), %rax    # 0x449910
jmp 0x1b0274
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b026d
leaq 0x8bbcd(%rip), %rax     # 0x23be38
jmp 0x1b0274
leaq 0x1a57bc(%rip), %rax    # 0x355a30
movq %rax, 0x58b205(%rip)    # 0x73b480
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/nw_dispatch.c
// Function: parasail_nw_trace_striped_32_dispatcher
parasail_result_t* parasail_nw_trace_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_32_pointer = parasail_nw_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_trace_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_trace_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b02ce
leaq 0x3affc0(%rip), %rax    # 0x56028c
jmp 0x1b02fd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b02e2
leaq 0x29c4ec(%rip), %rax    # 0x44c7cc
jmp 0x1b02fd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b02f6
leaq 0x8bb44(%rip), %rax     # 0x23be38
jmp 0x1b02fd
leaq 0x1a91e7(%rip), %rax    # 0x3594e4
movq %rax, 0x58b184(%rip)    # 0x73b488
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/nw_dispatch.c
// Function: parasail_nw_trace_striped_16_dispatcher
parasail_result_t* parasail_nw_trace_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_16_pointer = parasail_nw_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_trace_striped_16_pointer = parasail_nw;
    }
    return parasail_nw_trace_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0357
leaq 0x3b23a7(%rip), %rax    # 0x5626fc
jmp 0x1b0386
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b036b
leaq 0x29e8ef(%rip), %rax    # 0x44ec58
jmp 0x1b0386
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b037f
leaq 0x8babb(%rip), %rax     # 0x23be38
jmp 0x1b0386
leaq 0x1ab9d2(%rip), %rax    # 0x35bd58
movq %rax, 0x58b103(%rip)    # 0x73b490
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/nw_dispatch.c
// Function: parasail_nw_trace_striped_8_dispatcher
parasail_result_t* parasail_nw_trace_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_striped_8_pointer = parasail_nw_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_trace_striped_8_pointer = parasail_nw;
    }
    return parasail_nw_trace_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b03e0
leaq 0x3b489a(%rip), %rax    # 0x564c78
jmp 0x1b040f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b03f4
leaq 0x2a0e0a(%rip), %rax    # 0x4511fc
jmp 0x1b040f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b0408
leaq 0x8ba32(%rip), %rax     # 0x23be38
jmp 0x1b040f
leaq 0x1adf75(%rip), %rax    # 0x35e384
movq %rax, 0x58b082(%rip)    # 0x73b498
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/nw_dispatch.c
// Function: parasail_nw_trace_diag_64_dispatcher
parasail_result_t* parasail_nw_trace_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_64_pointer = parasail_nw_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_trace_diag_64_pointer = parasail_nw;
    }
    return parasail_nw_trace_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0469
leaq 0x39d595(%rip), %rax    # 0x54d9fc
jmp 0x1b0498
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b047d
leaq 0x28e2d9(%rip), %rax    # 0x43e754
jmp 0x1b0498
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b0491
leaq 0x8b9a9(%rip), %rax     # 0x23be38
jmp 0x1b0498
leaq 0x199310(%rip), %rax    # 0x3497a8
movq %rax, 0x58b001(%rip)    # 0x73b4a0
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/nw_dispatch.c
// Function: parasail_nw_trace_diag_32_dispatcher
parasail_result_t* parasail_nw_trace_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_32_pointer = parasail_nw_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_trace_diag_32_pointer = parasail_nw;
    }
    return parasail_nw_trace_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b04f2
leaq 0x39fc04(%rip), %rax    # 0x5500f4
jmp 0x1b0521
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0506
leaq 0x290580(%rip), %rax    # 0x440a84
jmp 0x1b0521
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b051a
leaq 0x8b920(%rip), %rax     # 0x23be38
jmp 0x1b0521
leaq 0x19bd1f(%rip), %rax    # 0x34c240
movq %rax, 0x58af80(%rip)    # 0x73b4a8
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/nw_dispatch.c
// Function: parasail_nw_trace_diag_16_dispatcher
parasail_result_t* parasail_nw_trace_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_16_pointer = parasail_nw_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_trace_diag_16_pointer = parasail_nw;
    }
    return parasail_nw_trace_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b057b
leaq 0x3a26bb(%rip), %rax    # 0x552c34
jmp 0x1b05aa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b058f
leaq 0x2925cb(%rip), %rax    # 0x442b58
jmp 0x1b05aa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b05a3
leaq 0x8b897(%rip), %rax     # 0x23be38
jmp 0x1b05aa
leaq 0x19dfa2(%rip), %rax    # 0x34e54c
movq %rax, 0x58aeff(%rip)    # 0x73b4b0
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/nw_dispatch.c
// Function: parasail_nw_trace_diag_8_dispatcher
parasail_result_t* parasail_nw_trace_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_trace_diag_8_pointer = parasail_nw_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_trace_diag_8_pointer = parasail_nw;
    }
    return parasail_nw_trace_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0604
leaq 0x3a666e(%rip), %rax    # 0x556c70
jmp 0x1b0633
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0618
leaq 0x29513a(%rip), %rax    # 0x445750
jmp 0x1b0633
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b062c
leaq 0x8b80e(%rip), %rax     # 0x23be38
jmp 0x1b0633
leaq 0x1a0be9(%rip), %rax    # 0x35121c
movq %rax, 0x58ae7e(%rip)    # 0x73b4b8
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/nw_dispatch.c
// Function: parasail_nw_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_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_scan_profile_64_pointer = parasail_nw_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_64_pointer = parasail_nw_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0686
leaq 0x2a32cb(%rip), %rax    # 0x45394f
jmp 0x1b06ac
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b069a
leaq 0x1b090b(%rip), %rax    # 0x360fa3
jmp 0x1b06ac
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b06cb
leaq 0x9f3cb(%rip), %rax     # 0x24fa77
movq %rax, 0x58ae0d(%rip)    # 0x73b4c0
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/nw_dispatch.c
// Function: parasail_nw_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_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_scan_profile_32_pointer = parasail_nw_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_32_pointer = parasail_nw_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0700
leaq 0x2a53f1(%rip), %rax    # 0x455aef
jmp 0x1b0726
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0714
leaq 0x1b2659(%rip), %rax    # 0x362d6b
jmp 0x1b0726
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0745
leaq 0xa1811(%rip), %rax     # 0x251f37
movq %rax, 0x58ad9b(%rip)    # 0x73b4c8
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/nw_dispatch.c
// Function: parasail_nw_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_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_scan_profile_16_pointer = parasail_nw_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_16_pointer = parasail_nw_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x1b077a
leaq 0x2a6e87(%rip), %rax    # 0x4575ff
jmp 0x1b07a0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b078e
leaq 0x1b40ab(%rip), %rax    # 0x364837
jmp 0x1b07a0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b07bf
leaq 0xa35c3(%rip), %rax     # 0x253d63
movq %rax, 0x58ad29(%rip)    # 0x73b4d0
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/nw_dispatch.c
// Function: parasail_nw_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_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_scan_profile_8_pointer = parasail_nw_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_profile_8_pointer = parasail_nw_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x1b07f4
leaq 0x2a8991(%rip), %rax    # 0x459183
jmp 0x1b081a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0808
leaq 0x1b5bdd(%rip), %rax    # 0x3663e3
jmp 0x1b081a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0839
leaq 0xa5175(%rip), %rax     # 0x25598f
movq %rax, 0x58acb7(%rip)    # 0x73b4d8
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/nw_dispatch.c
// Function: parasail_nw_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_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_striped_profile_64_pointer = parasail_nw_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_64_pointer = parasail_nw_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x1b086e
leaq 0x2b4203(%rip), %rax    # 0x464a6f
jmp 0x1b0894
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0882
leaq 0x1bf557(%rip), %rax    # 0x36fdd7
jmp 0x1b0894
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b08b3
leaq 0xb053f(%rip), %rax     # 0x260dd3
movq %rax, 0x58ac45(%rip)    # 0x73b4e0
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/nw_dispatch.c
// Function: parasail_nw_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_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_striped_profile_32_pointer = parasail_nw_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_32_pointer = parasail_nw_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x1b08e8
leaq 0x2b60f5(%rip), %rax    # 0x4669db
jmp 0x1b090e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b08fc
leaq 0x1c1329(%rip), %rax    # 0x371c23
jmp 0x1b090e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b092d
leaq 0xb2a4d(%rip), %rax     # 0x26335b
movq %rax, 0x58abd3(%rip)    # 0x73b4e8
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/nw_dispatch.c
// Function: parasail_nw_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_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_striped_profile_16_pointer = parasail_nw_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_16_pointer = parasail_nw_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x1b0962
leaq 0x2b7937(%rip), %rax    # 0x468297
jmp 0x1b0988
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0976
leaq 0x1c2b47(%rip), %rax    # 0x3734bb
jmp 0x1b0988
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b09a7
leaq 0xb45af(%rip), %rax     # 0x264f37
movq %rax, 0x58ab61(%rip)    # 0x73b4f0
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/nw_dispatch.c
// Function: parasail_nw_striped_profile_8_dispatcher
parasail_result_t* parasail_nw_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_striped_profile_8_pointer = parasail_nw_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_profile_8_pointer = parasail_nw_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_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 0x1b09dc
leaq 0x2b9295(%rip), %rax    # 0x469c6f
jmp 0x1b0a02
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b09f0
leaq 0x1c446d(%rip), %rax    # 0x374e5b
jmp 0x1b0a02
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0a21
leaq 0xb5f35(%rip), %rax     # 0x266937
movq %rax, 0x58aaef(%rip)    # 0x73b4f8
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/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_64_pointer = parasail_nw_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0a56
leaq 0x2babe0(%rip), %rax    # 0x46b634
jmp 0x1b0a7c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0a6a
leaq 0x1c647c(%rip), %rax    # 0x376ee4
jmp 0x1b0a7c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0a9b
leaq 0xb7c2c(%rip), %rax     # 0x2686a8
movq %rax, 0x58aa7d(%rip)    # 0x73b500
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/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_nw_stats_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_32_pointer = parasail_nw_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b0ad0
leaq 0x2bee9a(%rip), %rax    # 0x46f968
jmp 0x1b0af6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0ae4
leaq 0x1ca406(%rip), %rax    # 0x37aee8
jmp 0x1b0af6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0b15
leaq 0xbc992(%rip), %rax     # 0x26d488
movq %rax, 0x58aa0b(%rip)    # 0x73b508
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/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_nw_stats_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_scan_profile_16_pointer = parasail_nw_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_16_pointer = parasail_nw_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_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 0x1b0b4a
leaq 0x2c20b8(%rip), %rax    # 0x472c00
jmp 0x1b0b70
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0b5e
leaq 0x1cd630(%rip), %rax    # 0x37e18c
jmp 0x1b0b70
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0b8f
leaq 0xc0268(%rip), %rax     # 0x270dd8
movq %rax, 0x58a999(%rip)    # 0x73b510
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/nw_dispatch.c
// Function: parasail_nw_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_nw_stats_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_scan_profile_8_pointer = parasail_nw_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_scan_profile_8_pointer = parasail_nw_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_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 0x1b0bc4
leaq 0x2c5396(%rip), %rax    # 0x475f58
jmp 0x1b0bea
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0bd8
leaq 0x1d0952(%rip), %rax    # 0x381528
jmp 0x1b0bea
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0c09
leaq 0xc38ea(%rip), %rax     # 0x2744d4
movq %rax, 0x58a927(%rip)    # 0x73b518
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/nw_dispatch.c
// Function: parasail_nw_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_nw_stats_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_striped_profile_64_pointer = parasail_nw_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_profile_64_pointer = parasail_nw_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_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 0x1b0c3e
leaq 0x2d8f44(%rip), %rax    # 0x489b80
jmp 0x1b0c64
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0c52
leaq 0x1e2794(%rip), %rax    # 0x3933e4
jmp 0x1b0c64
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0c83
leaq 0xd8178(%rip), %rax     # 0x288ddc
movq %rax, 0x58a8b5(%rip)    # 0x73b520
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/nw_dispatch.c
// Function: parasail_nw_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_nw_stats_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_striped_profile_32_pointer = parasail_nw_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_profile_32_pointer = parasail_nw_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_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 0x1b0cb8
leaq 0x2dcaea(%rip), %rax    # 0x48d7a0
jmp 0x1b0cde
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0ccc
leaq 0x1e62fa(%rip), %rax    # 0x396fc4
jmp 0x1b0cde
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0cfd
leaq 0xdcb2a(%rip), %rax     # 0x28d808
movq %rax, 0x58a843(%rip)    # 0x73b528
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/nw_dispatch.c
// Function: parasail_nw_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_nw_stats_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_striped_profile_16_pointer = parasail_nw_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_stats_striped_profile_16_pointer = parasail_nw_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_nw_stats_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 0x1b0d32
leaq 0x2dfab8(%rip), %rax    # 0x4907e8
jmp 0x1b0d58
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b0d46
leaq 0x1e9428(%rip), %rax    # 0x39a16c
jmp 0x1b0d58
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1b0d77
leaq 0xe02a0(%rip), %rax     # 0x290ff8
movq %rax, 0x58a7d1(%rip)    # 0x73b530
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