LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_profile_16_pointer = parasail_sw_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_16_pointer = parasail_sw_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd286
leaq 0x6b4103(%rip), %rax    # 0x891380
movq %rax, 0xc4ab0c(%rip)    # 0xe27d90
jmp 0x1dd2cc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd2a2
leaq 0x3c83b7(%rip), %rax    # 0x5a5650
movq %rax, 0xc4aaf0(%rip)    # 0xe27d90
jmp 0x1dd2ca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd2be
leaq 0xee77b(%rip), %rax     # 0x2cba30
movq %rax, 0xc4aad4(%rip)    # 0xe27d90
jmp 0x1dd2c8
movq $0x0, -0x8(%rbp)
jmp 0x1dd2eb
jmp 0x1dd2ca
jmp 0x1dd2cc
movq 0xc4aabd(%rip), %rax    # 0xe27d90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_scan_profile_8_pointer = parasail_sw_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_scan_profile_8_pointer = parasail_sw_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd336
leaq 0x6bce23(%rip), %rax    # 0x89a150
movq %rax, 0xc4aa64(%rip)    # 0xe27d98
jmp 0x1dd37c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd352
leaq 0x3ce277(%rip), %rax    # 0x5ab5c0
movq %rax, 0xc4aa48(%rip)    # 0xe27d98
jmp 0x1dd37a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd36e
leaq 0xf495b(%rip), %rax     # 0x2d1cc0
movq %rax, 0xc4aa2c(%rip)    # 0xe27d98
jmp 0x1dd378
movq $0x0, -0x8(%rbp)
jmp 0x1dd39b
jmp 0x1dd37a
jmp 0x1dd37c
movq 0xc4aa15(%rip), %rax    # 0xe27d98
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_profile_64_pointer = parasail_sw_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_64_pointer = parasail_sw_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd3e6
leaq 0x6f1f73(%rip), %rax    # 0x8cf350
movq %rax, 0xc4a9bc(%rip)    # 0xe27da0
jmp 0x1dd42c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd402
leaq 0x3f1297(%rip), %rax    # 0x5ce690
movq %rax, 0xc4a9a0(%rip)    # 0xe27da0
jmp 0x1dd42a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd41e
leaq 0x11878b(%rip), %rax    # 0x2f5ba0
movq %rax, 0xc4a984(%rip)    # 0xe27da0
jmp 0x1dd428
movq $0x0, -0x8(%rbp)
jmp 0x1dd44b
jmp 0x1dd42a
jmp 0x1dd42c
movq 0xc4a96d(%rip), %rax    # 0xe27da0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_profile_32_pointer = parasail_sw_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_32_pointer = parasail_sw_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd496
leaq 0x6f74e3(%rip), %rax    # 0x8d4970
movq %rax, 0xc4a914(%rip)    # 0xe27da8
jmp 0x1dd4dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd4b2
leaq 0x3f5c37(%rip), %rax    # 0x5d30e0
movq %rax, 0xc4a8f8(%rip)    # 0xe27da8
jmp 0x1dd4da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd4ce
leaq 0x11d2ab(%rip), %rax    # 0x2fa770
movq %rax, 0xc4a8dc(%rip)    # 0xe27da8
jmp 0x1dd4d8
movq $0x0, -0x8(%rbp)
jmp 0x1dd4fb
jmp 0x1dd4da
jmp 0x1dd4dc
movq 0xc4a8c5(%rip), %rax    # 0xe27da8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_profile_16_pointer = parasail_sw_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_16_pointer = parasail_sw_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd546
leaq 0x6fd3b3(%rip), %rax    # 0x8da8f0
movq %rax, 0xc4a86c(%rip)    # 0xe27db0
jmp 0x1dd58c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd562
leaq 0x3fa9d7(%rip), %rax    # 0x5d7f30
movq %rax, 0xc4a850(%rip)    # 0xe27db0
jmp 0x1dd58a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd57e
leaq 0x12210b(%rip), %rax    # 0x2ff680
movq %rax, 0xc4a834(%rip)    # 0xe27db0
jmp 0x1dd588
movq $0x0, -0x8(%rbp)
jmp 0x1dd5ab
jmp 0x1dd58a
jmp 0x1dd58c
movq 0xc4a81d(%rip), %rax    # 0xe27db0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_striped_profile_8_pointer = parasail_sw_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_striped_profile_8_pointer = parasail_sw_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd5f6
leaq 0x704543(%rip), %rax    # 0x8e1b30
movq %rax, 0xc4a7c4(%rip)    # 0xe27db8
jmp 0x1dd63c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd612
leaq 0x3fffc7(%rip), %rax    # 0x5dd5d0
movq %rax, 0xc4a7a8(%rip)    # 0xe27db8
jmp 0x1dd63a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd62e
leaq 0x1279fb(%rip), %rax    # 0x305020
movq %rax, 0xc4a78c(%rip)    # 0xe27db8
jmp 0x1dd638
movq $0x0, -0x8(%rbp)
jmp 0x1dd65b
jmp 0x1dd63a
jmp 0x1dd63c
movq 0xc4a775(%rip), %rax    # 0xe27db8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_64_pointer = parasail_sw_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd6a6
leaq 0x70f6c3(%rip), %rax    # 0x8ecd60
movq %rax, 0xc4a71c(%rip)    # 0xe27dc0
jmp 0x1dd6ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd6c2
leaq 0x40a647(%rip), %rax    # 0x5e7d00
movq %rax, 0xc4a700(%rip)    # 0xe27dc0
jmp 0x1dd6ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd6de
leaq 0x13018b(%rip), %rax    # 0x30d860
movq %rax, 0xc4a6e4(%rip)    # 0xe27dc0
jmp 0x1dd6e8
movq $0x0, -0x8(%rbp)
jmp 0x1dd70b
jmp 0x1dd6ea
jmp 0x1dd6ec
movq 0xc4a6cd(%rip), %rax    # 0xe27dc0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_32_pointer = parasail_sw_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd756
leaq 0x71c8c3(%rip), %rax    # 0x8fa010
movq %rax, 0xc4a674(%rip)    # 0xe27dc8
jmp 0x1dd79c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd772
leaq 0x414fe7(%rip), %rax    # 0x5f2750
movq %rax, 0xc4a658(%rip)    # 0xe27dc8
jmp 0x1dd79a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd78e
leaq 0x139dcb(%rip), %rax    # 0x317550
movq %rax, 0xc4a63c(%rip)    # 0xe27dc8
jmp 0x1dd798
movq $0x0, -0x8(%rbp)
jmp 0x1dd7bb
jmp 0x1dd79a
jmp 0x1dd79c
movq 0xc4a625(%rip), %rax    # 0xe27dc8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_16_pointer = parasail_sw_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd806
leaq 0x72b083(%rip), %rax    # 0x908880
movq %rax, 0xc4a5cc(%rip)    # 0xe27dd0
jmp 0x1dd84c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd822
leaq 0x420067(%rip), %rax    # 0x5fd880
movq %rax, 0xc4a5b0(%rip)    # 0xe27dd0
jmp 0x1dd84a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd83e
leaq 0x14407b(%rip), %rax    # 0x3218b0
movq %rax, 0xc4a594(%rip)    # 0xe27dd0
jmp 0x1dd848
movq $0x0, -0x8(%rbp)
jmp 0x1dd86b
jmp 0x1dd84a
jmp 0x1dd84c
movq 0xc4a57d(%rip), %rax    # 0xe27dd0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_scan_profile_8_pointer = parasail_sw_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd8b6
leaq 0x73bfc3(%rip), %rax    # 0x919870
movq %rax, 0xc4a524(%rip)    # 0xe27dd8
jmp 0x1dd8fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd8d2
leaq 0x42bba7(%rip), %rax    # 0x609470
movq %rax, 0xc4a508(%rip)    # 0xe27dd8
jmp 0x1dd8fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd8ee
leaq 0x14effb(%rip), %rax    # 0x32c8e0
movq %rax, 0xc4a4ec(%rip)    # 0xe27dd8
jmp 0x1dd8f8
movq $0x0, -0x8(%rbp)
jmp 0x1dd91b
jmp 0x1dd8fa
jmp 0x1dd8fc
movq 0xc4a4d5(%rip), %rax    # 0xe27dd8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_64_pointer = parasail_sw_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dd966
leaq 0x78cc43(%rip), %rax    # 0x96a5a0
movq %rax, 0xc4a47c(%rip)    # 0xe27de0
jmp 0x1dd9ac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dd982
leaq 0x463d37(%rip), %rax    # 0x6416b0
movq %rax, 0xc4a460(%rip)    # 0xe27de0
jmp 0x1dd9aa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dd99e
leaq 0x1853fb(%rip), %rax    # 0x362d90
movq %rax, 0xc4a444(%rip)    # 0xe27de0
jmp 0x1dd9a8
movq $0x0, -0x8(%rbp)
jmp 0x1dd9cb
jmp 0x1dd9aa
jmp 0x1dd9ac
movq 0xc4a42d(%rip), %rax    # 0xe27de0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_32_pointer = parasail_sw_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dda16
leaq 0x797b53(%rip), %rax    # 0x975560
movq %rax, 0xc4a3d4(%rip)    # 0xe27de8
jmp 0x1dda5c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dda32
leaq 0x46d127(%rip), %rax    # 0x64ab50
movq %rax, 0xc4a3b8(%rip)    # 0xe27de8
jmp 0x1dda5a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dda4e
leaq 0x18e0eb(%rip), %rax    # 0x36bb30
movq %rax, 0xc4a39c(%rip)    # 0xe27de8
jmp 0x1dda58
movq $0x0, -0x8(%rbp)
jmp 0x1dda7b
jmp 0x1dda5a
jmp 0x1dda5c
movq 0xc4a385(%rip), %rax    # 0xe27de8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_16_pointer = parasail_sw_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ddac6
leaq 0x7a36e3(%rip), %rax    # 0x9811a0
movq %rax, 0xc4a32c(%rip)    # 0xe27df0
jmp 0x1ddb0c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ddae2
leaq 0x476ae7(%rip), %rax    # 0x6545c0
movq %rax, 0xc4a310(%rip)    # 0xe27df0
jmp 0x1ddb0a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ddafe
leaq 0x19723b(%rip), %rax    # 0x374d30
movq %rax, 0xc4a2f4(%rip)    # 0xe27df0
jmp 0x1ddb08
movq $0x0, -0x8(%rbp)
jmp 0x1ddb2b
jmp 0x1ddb0a
jmp 0x1ddb0c
movq 0xc4a2dd(%rip), %rax    # 0xe27df0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_stats_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_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_striped_profile_8_pointer = parasail_sw_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ddb76
leaq 0x7b0b43(%rip), %rax    # 0x98e6b0
movq %rax, 0xc4a284(%rip)    # 0xe27df8
jmp 0x1ddbbc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ddb92
leaq 0x481147(%rip), %rax    # 0x65ecd0
movq %rax, 0xc4a268(%rip)    # 0xe27df8
jmp 0x1ddbba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ddbae
leaq 0x1a106b(%rip), %rax    # 0x37ec10
movq %rax, 0xc4a24c(%rip)    # 0xe27df8
jmp 0x1ddbb8
movq $0x0, -0x8(%rbp)
jmp 0x1ddbdb
jmp 0x1ddbba
jmp 0x1ddbbc
movq 0xc4a235(%rip), %rax    # 0xe27df8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_table_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_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_64_pointer = parasail_sw_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_table_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ddc26
leaq 0x7bc833(%rip), %rax    # 0x99a450
movq %rax, 0xc4a1dc(%rip)    # 0xe27e00
jmp 0x1ddc6c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ddc42
leaq 0x488777(%rip), %rax    # 0x6663b0
movq %rax, 0xc4a1c0(%rip)    # 0xe27e00
jmp 0x1ddc6a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ddc5e
leaq 0x1aa78b(%rip), %rax    # 0x3883e0
movq %rax, 0xc4a1a4(%rip)    # 0xe27e00
jmp 0x1ddc68
movq $0x0, -0x8(%rbp)
jmp 0x1ddc8b
jmp 0x1ddc6a
jmp 0x1ddc6c
movq 0xc4a18d(%rip), %rax    # 0xe27e00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_table_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_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_32_pointer = parasail_sw_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_table_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ddcd6
leaq 0x7c31a3(%rip), %rax    # 0x9a0e70
movq %rax, 0xc4a134(%rip)    # 0xe27e08
jmp 0x1ddd1c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ddcf2
leaq 0x48dc17(%rip), %rax    # 0x66b900
movq %rax, 0xc4a118(%rip)    # 0xe27e08
jmp 0x1ddd1a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ddd0e
leaq 0x1afecb(%rip), %rax    # 0x38dbd0
movq %rax, 0xc4a0fc(%rip)    # 0xe27e08
jmp 0x1ddd18
movq $0x0, -0x8(%rbp)
jmp 0x1ddd3b
jmp 0x1ddd1a
jmp 0x1ddd1c
movq 0xc4a0e5(%rip), %rax    # 0xe27e08
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_table_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_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_16_pointer = parasail_sw_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_table_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ddd86
leaq 0x7cae73(%rip), %rax    # 0x9a8bf0
movq %rax, 0xc4a08c(%rip)    # 0xe27e10
jmp 0x1dddcc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ddda2
leaq 0x4937d7(%rip), %rax    # 0x671570
movq %rax, 0xc4a070(%rip)    # 0xe27e10
jmp 0x1dddca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dddbe
leaq 0x1b5c1b(%rip), %rax    # 0x3939d0
movq %rax, 0xc4a054(%rip)    # 0xe27e10
jmp 0x1dddc8
movq $0x0, -0x8(%rbp)
jmp 0x1dddeb
jmp 0x1dddca
jmp 0x1dddcc
movq 0xc4a03d(%rip), %rax    # 0xe27e10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_table_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_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_profile_8_pointer = parasail_sw_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_table_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1dde36
leaq 0x7d4ff3(%rip), %rax    # 0x9b2e20
movq %rax, 0xc49fe4(%rip)    # 0xe27e18
jmp 0x1dde7c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1dde52
leaq 0x499ff7(%rip), %rax    # 0x677e40
movq %rax, 0xc49fc8(%rip)    # 0xe27e18
jmp 0x1dde7a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1dde6e
leaq 0x1bc7bb(%rip), %rax    # 0x39a620
movq %rax, 0xc49fac(%rip)    # 0xe27e18
jmp 0x1dde78
movq $0x0, -0x8(%rbp)
jmp 0x1dde9b
jmp 0x1dde7a
jmp 0x1dde7c
movq 0xc49f95(%rip), %rax    # 0xe27e18
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_table_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_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_profile_64_pointer = parasail_sw_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_table_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ddee6
leaq 0x8100c3(%rip), %rax    # 0x9edfa0
movq %rax, 0xc49f3c(%rip)    # 0xe27e20
jmp 0x1ddf2c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ddf02
leaq 0x4bfdd7(%rip), %rax    # 0x69dcd0
movq %rax, 0xc49f20(%rip)    # 0xe27e20
jmp 0x1ddf2a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ddf1e
leaq 0x1e35ab(%rip), %rax    # 0x3c14c0
movq %rax, 0xc49f04(%rip)    # 0xe27e20
jmp 0x1ddf28
movq $0x0, -0x8(%rbp)
jmp 0x1ddf4b
jmp 0x1ddf2a
jmp 0x1ddf2c
movq 0xc49eed(%rip), %rax    # 0xe27e20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_table_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_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_profile_32_pointer = parasail_sw_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_table_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ddf96
leaq 0x815c23(%rip), %rax    # 0x9f3bb0
movq %rax, 0xc49e94(%rip)    # 0xe27e28
jmp 0x1ddfdc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ddfb2
leaq 0x4c4ae7(%rip), %rax    # 0x6a2a90
movq %rax, 0xc49e78(%rip)    # 0xe27e28
jmp 0x1ddfda
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ddfce
leaq 0x1e84fb(%rip), %rax    # 0x3c64c0
movq %rax, 0xc49e5c(%rip)    # 0xe27e28
jmp 0x1ddfd8
movq $0x0, -0x8(%rbp)
jmp 0x1ddffb
jmp 0x1ddfda
jmp 0x1ddfdc
movq 0xc49e45(%rip), %rax    # 0xe27e28
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)