LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_scan_profile_16_pointer = parasail_sg_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_profile_16_pointer = parasail_sg_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_profile_16_pointer = parasail_sg_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_profile_16_pointer = parasail_sg_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_profile_16_pointer = parasail_sg_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d44c6
leaq 0x6bcc13(%rip), %rax    # 0x8910d0
movq %rax, 0xc5346c(%rip)    # 0xe27930
jmp 0x1d450c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d44e2
leaq 0x3d0ec7(%rip), %rax    # 0x5a53a0
movq %rax, 0xc53450(%rip)    # 0xe27930
jmp 0x1d450a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d44fe
leaq 0xf728b(%rip), %rax     # 0x2cb780
movq %rax, 0xc53434(%rip)    # 0xe27930
jmp 0x1d4508
movq $0x0, -0x8(%rbp)
jmp 0x1d452b
jmp 0x1d450a
jmp 0x1d450c
movq 0xc5341d(%rip), %rax    # 0xe27930
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/sg_dispatch.c
// Function: parasail_sg_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_scan_profile_8_pointer = parasail_sg_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_profile_8_pointer = parasail_sg_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_profile_8_pointer = parasail_sg_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_profile_8_pointer = parasail_sg_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_profile_8_pointer = parasail_sg_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4576
leaq 0x6c5933(%rip), %rax    # 0x899ea0
movq %rax, 0xc533c4(%rip)    # 0xe27938
jmp 0x1d45bc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4592
leaq 0x3d6d87(%rip), %rax    # 0x5ab310
movq %rax, 0xc533a8(%rip)    # 0xe27938
jmp 0x1d45ba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d45ae
leaq 0xfd46b(%rip), %rax     # 0x2d1a10
movq %rax, 0xc5338c(%rip)    # 0xe27938
jmp 0x1d45b8
movq $0x0, -0x8(%rbp)
jmp 0x1d45db
jmp 0x1d45ba
jmp 0x1d45bc
movq 0xc53375(%rip), %rax    # 0xe27938
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/sg_dispatch.c
// Function: parasail_sg_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_striped_profile_64_pointer = parasail_sg_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_profile_64_pointer = parasail_sg_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_profile_64_pointer = parasail_sg_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_profile_64_pointer = parasail_sg_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_profile_64_pointer = parasail_sg_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4626
leaq 0x6faa83(%rip), %rax    # 0x8cf0a0
movq %rax, 0xc5331c(%rip)    # 0xe27940
jmp 0x1d466c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4642
leaq 0x3f9da7(%rip), %rax    # 0x5ce3e0
movq %rax, 0xc53300(%rip)    # 0xe27940
jmp 0x1d466a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d465e
leaq 0x12129b(%rip), %rax    # 0x2f58f0
movq %rax, 0xc532e4(%rip)    # 0xe27940
jmp 0x1d4668
movq $0x0, -0x8(%rbp)
jmp 0x1d468b
jmp 0x1d466a
jmp 0x1d466c
movq 0xc532cd(%rip), %rax    # 0xe27940
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/sg_dispatch.c
// Function: parasail_sg_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_striped_profile_32_pointer = parasail_sg_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_profile_32_pointer = parasail_sg_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_profile_32_pointer = parasail_sg_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_profile_32_pointer = parasail_sg_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_profile_32_pointer = parasail_sg_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d46d6
leaq 0x6ffff3(%rip), %rax    # 0x8d46c0
movq %rax, 0xc53274(%rip)    # 0xe27948
jmp 0x1d471c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d46f2
leaq 0x3fe747(%rip), %rax    # 0x5d2e30
movq %rax, 0xc53258(%rip)    # 0xe27948
jmp 0x1d471a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d470e
leaq 0x125dbb(%rip), %rax    # 0x2fa4c0
movq %rax, 0xc5323c(%rip)    # 0xe27948
jmp 0x1d4718
movq $0x0, -0x8(%rbp)
jmp 0x1d473b
jmp 0x1d471a
jmp 0x1d471c
movq 0xc53225(%rip), %rax    # 0xe27948
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/sg_dispatch.c
// Function: parasail_sg_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_striped_profile_16_pointer = parasail_sg_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_profile_16_pointer = parasail_sg_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_profile_16_pointer = parasail_sg_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_profile_16_pointer = parasail_sg_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_profile_16_pointer = parasail_sg_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4786
leaq 0x705ec3(%rip), %rax    # 0x8da640
movq %rax, 0xc531cc(%rip)    # 0xe27950
jmp 0x1d47cc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d47a2
leaq 0x4034e7(%rip), %rax    # 0x5d7c80
movq %rax, 0xc531b0(%rip)    # 0xe27950
jmp 0x1d47ca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d47be
leaq 0x12ac1b(%rip), %rax    # 0x2ff3d0
movq %rax, 0xc53194(%rip)    # 0xe27950
jmp 0x1d47c8
movq $0x0, -0x8(%rbp)
jmp 0x1d47eb
jmp 0x1d47ca
jmp 0x1d47cc
movq 0xc5317d(%rip), %rax    # 0xe27950
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/sg_dispatch.c
// Function: parasail_sg_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_striped_profile_8_pointer = parasail_sg_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_profile_8_pointer = parasail_sg_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_profile_8_pointer = parasail_sg_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_profile_8_pointer = parasail_sg_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_profile_8_pointer = parasail_sg_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4836
leaq 0x70d053(%rip), %rax    # 0x8e1880
movq %rax, 0xc53124(%rip)    # 0xe27958
jmp 0x1d487c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4852
leaq 0x408ad7(%rip), %rax    # 0x5dd320
movq %rax, 0xc53108(%rip)    # 0xe27958
jmp 0x1d487a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d486e
leaq 0x13050b(%rip), %rax    # 0x304d70
movq %rax, 0xc530ec(%rip)    # 0xe27958
jmp 0x1d4878
movq $0x0, -0x8(%rbp)
jmp 0x1d489b
jmp 0x1d487a
jmp 0x1d487c
movq 0xc530d5(%rip), %rax    # 0xe27958
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/sg_dispatch.c
// Function: parasail_sg_stats_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_scan_profile_64_pointer = parasail_sg_stats_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_profile_64_pointer = parasail_sg_stats_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_profile_64_pointer = parasail_sg_stats_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_profile_64_pointer = parasail_sg_stats_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_profile_64_pointer = parasail_sg_stats_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d48e6
leaq 0x7181a3(%rip), %rax    # 0x8eca80
movq %rax, 0xc5307c(%rip)    # 0xe27960
jmp 0x1d492c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4902
leaq 0x413127(%rip), %rax    # 0x5e7a20
movq %rax, 0xc53060(%rip)    # 0xe27960
jmp 0x1d492a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d491e
leaq 0x138c6b(%rip), %rax    # 0x30d580
movq %rax, 0xc53044(%rip)    # 0xe27960
jmp 0x1d4928
movq $0x0, -0x8(%rbp)
jmp 0x1d494b
jmp 0x1d492a
jmp 0x1d492c
movq 0xc5302d(%rip), %rax    # 0xe27960
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/sg_dispatch.c
// Function: parasail_sg_stats_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_scan_profile_32_pointer = parasail_sg_stats_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_profile_32_pointer = parasail_sg_stats_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_profile_32_pointer = parasail_sg_stats_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_profile_32_pointer = parasail_sg_stats_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_profile_32_pointer = parasail_sg_stats_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4996
leaq 0x7253a3(%rip), %rax    # 0x8f9d30
movq %rax, 0xc52fd4(%rip)    # 0xe27968
jmp 0x1d49dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d49b2
leaq 0x41dac7(%rip), %rax    # 0x5f2470
movq %rax, 0xc52fb8(%rip)    # 0xe27968
jmp 0x1d49da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d49ce
leaq 0x1428ab(%rip), %rax    # 0x317270
movq %rax, 0xc52f9c(%rip)    # 0xe27968
jmp 0x1d49d8
movq $0x0, -0x8(%rbp)
jmp 0x1d49fb
jmp 0x1d49da
jmp 0x1d49dc
movq 0xc52f85(%rip), %rax    # 0xe27968
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/sg_dispatch.c
// Function: parasail_sg_stats_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_scan_profile_16_pointer = parasail_sg_stats_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_profile_16_pointer = parasail_sg_stats_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_profile_16_pointer = parasail_sg_stats_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_profile_16_pointer = parasail_sg_stats_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_profile_16_pointer = parasail_sg_stats_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4a46
leaq 0x733b63(%rip), %rax    # 0x9085a0
movq %rax, 0xc52f2c(%rip)    # 0xe27970
jmp 0x1d4a8c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4a62
leaq 0x428b47(%rip), %rax    # 0x5fd5a0
movq %rax, 0xc52f10(%rip)    # 0xe27970
jmp 0x1d4a8a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4a7e
leaq 0x14cb5b(%rip), %rax    # 0x3215d0
movq %rax, 0xc52ef4(%rip)    # 0xe27970
jmp 0x1d4a88
movq $0x0, -0x8(%rbp)
jmp 0x1d4aab
jmp 0x1d4a8a
jmp 0x1d4a8c
movq 0xc52edd(%rip), %rax    # 0xe27970
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/sg_dispatch.c
// Function: parasail_sg_stats_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_scan_profile_8_pointer = parasail_sg_stats_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_profile_8_pointer = parasail_sg_stats_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_profile_8_pointer = parasail_sg_stats_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_profile_8_pointer = parasail_sg_stats_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_profile_8_pointer = parasail_sg_stats_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4af6
leaq 0x744aa3(%rip), %rax    # 0x919590
movq %rax, 0xc52e84(%rip)    # 0xe27978
jmp 0x1d4b3c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4b12
leaq 0x434687(%rip), %rax    # 0x609190
movq %rax, 0xc52e68(%rip)    # 0xe27978
jmp 0x1d4b3a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4b2e
leaq 0x157adb(%rip), %rax    # 0x32c600
movq %rax, 0xc52e4c(%rip)    # 0xe27978
jmp 0x1d4b38
movq $0x0, -0x8(%rbp)
jmp 0x1d4b5b
jmp 0x1d4b3a
jmp 0x1d4b3c
movq 0xc52e35(%rip), %rax    # 0xe27978
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/sg_dispatch.c
// Function: parasail_sg_stats_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_striped_profile_64_pointer = parasail_sg_stats_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_profile_64_pointer = parasail_sg_stats_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_profile_64_pointer = parasail_sg_stats_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_profile_64_pointer = parasail_sg_stats_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_profile_64_pointer = parasail_sg_stats_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4ba6
leaq 0x795723(%rip), %rax    # 0x96a2c0
movq %rax, 0xc52ddc(%rip)    # 0xe27980
jmp 0x1d4bec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4bc2
leaq 0x46c817(%rip), %rax    # 0x6413d0
movq %rax, 0xc52dc0(%rip)    # 0xe27980
jmp 0x1d4bea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4bde
leaq 0x18dedb(%rip), %rax    # 0x362ab0
movq %rax, 0xc52da4(%rip)    # 0xe27980
jmp 0x1d4be8
movq $0x0, -0x8(%rbp)
jmp 0x1d4c0b
jmp 0x1d4bea
jmp 0x1d4bec
movq 0xc52d8d(%rip), %rax    # 0xe27980
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/sg_dispatch.c
// Function: parasail_sg_stats_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_striped_profile_32_pointer = parasail_sg_stats_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_profile_32_pointer = parasail_sg_stats_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_profile_32_pointer = parasail_sg_stats_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_profile_32_pointer = parasail_sg_stats_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_profile_32_pointer = parasail_sg_stats_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4c56
leaq 0x7a0633(%rip), %rax    # 0x975280
movq %rax, 0xc52d34(%rip)    # 0xe27988
jmp 0x1d4c9c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4c72
leaq 0x475c07(%rip), %rax    # 0x64a870
movq %rax, 0xc52d18(%rip)    # 0xe27988
jmp 0x1d4c9a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4c8e
leaq 0x196bcb(%rip), %rax    # 0x36b850
movq %rax, 0xc52cfc(%rip)    # 0xe27988
jmp 0x1d4c98
movq $0x0, -0x8(%rbp)
jmp 0x1d4cbb
jmp 0x1d4c9a
jmp 0x1d4c9c
movq 0xc52ce5(%rip), %rax    # 0xe27988
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/sg_dispatch.c
// Function: parasail_sg_stats_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_striped_profile_16_pointer = parasail_sg_stats_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_profile_16_pointer = parasail_sg_stats_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_profile_16_pointer = parasail_sg_stats_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_profile_16_pointer = parasail_sg_stats_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_profile_16_pointer = parasail_sg_stats_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4d06
leaq 0x7ac1c3(%rip), %rax    # 0x980ec0
movq %rax, 0xc52c8c(%rip)    # 0xe27990
jmp 0x1d4d4c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4d22
leaq 0x47f5c7(%rip), %rax    # 0x6542e0
movq %rax, 0xc52c70(%rip)    # 0xe27990
jmp 0x1d4d4a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4d3e
leaq 0x19fd1b(%rip), %rax    # 0x374a50
movq %rax, 0xc52c54(%rip)    # 0xe27990
jmp 0x1d4d48
movq $0x0, -0x8(%rbp)
jmp 0x1d4d6b
jmp 0x1d4d4a
jmp 0x1d4d4c
movq 0xc52c3d(%rip), %rax    # 0xe27990
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/sg_dispatch.c
// Function: parasail_sg_stats_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_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_sg_stats_striped_profile_8_pointer = parasail_sg_stats_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_profile_8_pointer = parasail_sg_stats_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_profile_8_pointer = parasail_sg_stats_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_profile_8_pointer = parasail_sg_stats_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_profile_8_pointer = parasail_sg_stats_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4db6
leaq 0x7b9623(%rip), %rax    # 0x98e3d0
movq %rax, 0xc52be4(%rip)    # 0xe27998
jmp 0x1d4dfc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4dd2
leaq 0x489c27(%rip), %rax    # 0x65e9f0
movq %rax, 0xc52bc8(%rip)    # 0xe27998
jmp 0x1d4dfa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4dee
leaq 0x1a9b4b(%rip), %rax    # 0x37e930
movq %rax, 0xc52bac(%rip)    # 0xe27998
jmp 0x1d4df8
movq $0x0, -0x8(%rbp)
jmp 0x1d4e1b
jmp 0x1d4dfa
jmp 0x1d4dfc
movq 0xc52b95(%rip), %rax    # 0xe27998
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/sg_dispatch.c
// Function: parasail_sg_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_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_sg_table_scan_profile_64_pointer = parasail_sg_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_profile_64_pointer = parasail_sg_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_profile_64_pointer = parasail_sg_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_profile_64_pointer = parasail_sg_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_profile_64_pointer = parasail_sg_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4e66
leaq 0x7c5343(%rip), %rax    # 0x99a1a0
movq %rax, 0xc52b3c(%rip)    # 0xe279a0
jmp 0x1d4eac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4e82
leaq 0x491287(%rip), %rax    # 0x666100
movq %rax, 0xc52b20(%rip)    # 0xe279a0
jmp 0x1d4eaa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4e9e
leaq 0x1b329b(%rip), %rax    # 0x388130
movq %rax, 0xc52b04(%rip)    # 0xe279a0
jmp 0x1d4ea8
movq $0x0, -0x8(%rbp)
jmp 0x1d4ecb
jmp 0x1d4eaa
jmp 0x1d4eac
movq 0xc52aed(%rip), %rax    # 0xe279a0
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/sg_dispatch.c
// Function: parasail_sg_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_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_sg_table_scan_profile_32_pointer = parasail_sg_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_profile_32_pointer = parasail_sg_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_profile_32_pointer = parasail_sg_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_profile_32_pointer = parasail_sg_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_profile_32_pointer = parasail_sg_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4f16
leaq 0x7cbcb3(%rip), %rax    # 0x9a0bc0
movq %rax, 0xc52a94(%rip)    # 0xe279a8
jmp 0x1d4f5c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4f32
leaq 0x496727(%rip), %rax    # 0x66b650
movq %rax, 0xc52a78(%rip)    # 0xe279a8
jmp 0x1d4f5a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4f4e
leaq 0x1b89db(%rip), %rax    # 0x38d920
movq %rax, 0xc52a5c(%rip)    # 0xe279a8
jmp 0x1d4f58
movq $0x0, -0x8(%rbp)
jmp 0x1d4f7b
jmp 0x1d4f5a
jmp 0x1d4f5c
movq 0xc52a45(%rip), %rax    # 0xe279a8
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/sg_dispatch.c
// Function: parasail_sg_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_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_sg_table_scan_profile_16_pointer = parasail_sg_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_profile_16_pointer = parasail_sg_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_profile_16_pointer = parasail_sg_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_profile_16_pointer = parasail_sg_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_profile_16_pointer = parasail_sg_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d4fc6
leaq 0x7d3983(%rip), %rax    # 0x9a8940
movq %rax, 0xc529ec(%rip)    # 0xe279b0
jmp 0x1d500c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d4fe2
leaq 0x49c2e7(%rip), %rax    # 0x6712c0
movq %rax, 0xc529d0(%rip)    # 0xe279b0
jmp 0x1d500a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d4ffe
leaq 0x1be72b(%rip), %rax    # 0x393720
movq %rax, 0xc529b4(%rip)    # 0xe279b0
jmp 0x1d5008
movq $0x0, -0x8(%rbp)
jmp 0x1d502b
jmp 0x1d500a
jmp 0x1d500c
movq 0xc5299d(%rip), %rax    # 0xe279b0
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/sg_dispatch.c
// Function: parasail_sg_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_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_sg_table_scan_profile_8_pointer = parasail_sg_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_profile_8_pointer = parasail_sg_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_profile_8_pointer = parasail_sg_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_profile_8_pointer = parasail_sg_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_profile_8_pointer = parasail_sg_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d5076
leaq 0x7ddb03(%rip), %rax    # 0x9b2b70
movq %rax, 0xc52944(%rip)    # 0xe279b8
jmp 0x1d50bc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5092
leaq 0x4a2b07(%rip), %rax    # 0x677b90
movq %rax, 0xc52928(%rip)    # 0xe279b8
jmp 0x1d50ba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d50ae
leaq 0x1c52cb(%rip), %rax    # 0x39a370
movq %rax, 0xc5290c(%rip)    # 0xe279b8
jmp 0x1d50b8
movq $0x0, -0x8(%rbp)
jmp 0x1d50db
jmp 0x1d50ba
jmp 0x1d50bc
movq 0xc528f5(%rip), %rax    # 0xe279b8
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/sg_dispatch.c
// Function: parasail_sg_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_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_sg_table_striped_profile_64_pointer = parasail_sg_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_profile_64_pointer = parasail_sg_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_profile_64_pointer = parasail_sg_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_profile_64_pointer = parasail_sg_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_profile_64_pointer = parasail_sg_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d5126
leaq 0x818bd3(%rip), %rax    # 0x9edcf0
movq %rax, 0xc5289c(%rip)    # 0xe279c0
jmp 0x1d516c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5142
leaq 0x4c88e7(%rip), %rax    # 0x69da20
movq %rax, 0xc52880(%rip)    # 0xe279c0
jmp 0x1d516a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d515e
leaq 0x1ec0bb(%rip), %rax    # 0x3c1210
movq %rax, 0xc52864(%rip)    # 0xe279c0
jmp 0x1d5168
movq $0x0, -0x8(%rbp)
jmp 0x1d518b
jmp 0x1d516a
jmp 0x1d516c
movq 0xc5284d(%rip), %rax    # 0xe279c0
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/sg_dispatch.c
// Function: parasail_sg_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_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_sg_table_striped_profile_32_pointer = parasail_sg_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_profile_32_pointer = parasail_sg_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_profile_32_pointer = parasail_sg_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_profile_32_pointer = parasail_sg_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_profile_32_pointer = parasail_sg_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_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 0x1d51d6
leaq 0x81e733(%rip), %rax    # 0x9f3900
movq %rax, 0xc527f4(%rip)    # 0xe279c8
jmp 0x1d521c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d51f2
leaq 0x4cd5f7(%rip), %rax    # 0x6a27e0
movq %rax, 0xc527d8(%rip)    # 0xe279c8
jmp 0x1d521a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d520e
leaq 0x1f100b(%rip), %rax    # 0x3c6210
movq %rax, 0xc527bc(%rip)    # 0xe279c8
jmp 0x1d5218
movq $0x0, -0x8(%rbp)
jmp 0x1d523b
jmp 0x1d521a
jmp 0x1d521c
movq 0xc527a5(%rip), %rax    # 0xe279c8
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)