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_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_table_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_table_striped_profile_16_pointer = parasail_sg_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_profile_16_pointer = parasail_sg_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_profile_16_pointer = parasail_sg_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_profile_16_pointer = parasail_sg_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_profile_16_pointer = parasail_sg_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_table_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 0x1d5286
leaq 0x8250f3(%rip), %rax    # 0x9fa370
movq %rax, 0xc5274c(%rip)    # 0xe279d0
jmp 0x1d52cc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d52a2
leaq 0x4d2917(%rip), %rax    # 0x6a7bb0
movq %rax, 0xc52730(%rip)    # 0xe279d0
jmp 0x1d52ca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d52be
leaq 0x1f643b(%rip), %rax    # 0x3cb6f0
movq %rax, 0xc52714(%rip)    # 0xe279d0
jmp 0x1d52c8
movq $0x0, -0x8(%rbp)
jmp 0x1d52eb
jmp 0x1d52ca
jmp 0x1d52cc
movq 0xc526fd(%rip), %rax    # 0xe279d0
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_8_dispatcher
parasail_result_t* parasail_sg_table_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_table_striped_profile_8_pointer = parasail_sg_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_profile_8_pointer = parasail_sg_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_profile_8_pointer = parasail_sg_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_profile_8_pointer = parasail_sg_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_profile_8_pointer = parasail_sg_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_table_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 0x1d5336
leaq 0x82d803(%rip), %rax    # 0xa02b30
movq %rax, 0xc526a4(%rip)    # 0xe279d8
jmp 0x1d537c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5352
leaq 0x4d8937(%rip), %rax    # 0x6adc80
movq %rax, 0xc52688(%rip)    # 0xe279d8
jmp 0x1d537a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d536e
leaq 0x1fc7cb(%rip), %rax    # 0x3d1b30
movq %rax, 0xc5266c(%rip)    # 0xe279d8
jmp 0x1d5378
movq $0x0, -0x8(%rbp)
jmp 0x1d539b
jmp 0x1d537a
jmp 0x1d537c
movq 0xc52655(%rip), %rax    # 0xe279d8
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_table_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_scan_profile_64_pointer = parasail_sg_stats_table_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_profile_64_pointer = parasail_sg_stats_table_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_profile_64_pointer = parasail_sg_stats_table_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_profile_64_pointer = parasail_sg_stats_table_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_profile_64_pointer = parasail_sg_stats_table_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x1d53e6
leaq 0x839683(%rip), %rax    # 0xa0ea60
movq %rax, 0xc525fc(%rip)    # 0xe279e0
jmp 0x1d542c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5402
leaq 0x4e3997(%rip), %rax    # 0x6b8d90
movq %rax, 0xc525e0(%rip)    # 0xe279e0
jmp 0x1d542a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d541e
leaq 0x20569b(%rip), %rax    # 0x3daab0
movq %rax, 0xc525c4(%rip)    # 0xe279e0
jmp 0x1d5428
movq $0x0, -0x8(%rbp)
jmp 0x1d544b
jmp 0x1d542a
jmp 0x1d542c
movq 0xc525ad(%rip), %rax    # 0xe279e0
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_table_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_scan_profile_32_pointer = parasail_sg_stats_table_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_profile_32_pointer = parasail_sg_stats_table_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_profile_32_pointer = parasail_sg_stats_table_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_profile_32_pointer = parasail_sg_stats_table_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_profile_32_pointer = parasail_sg_stats_table_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x1d5496
leaq 0x847003(%rip), %rax    # 0xa1c490
movq %rax, 0xc52554(%rip)    # 0xe279e8
jmp 0x1d54dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d54b2
leaq 0x4ee827(%rip), %rax    # 0x6c3cd0
movq %rax, 0xc52538(%rip)    # 0xe279e8
jmp 0x1d54da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d54ce
leaq 0x20f87b(%rip), %rax    # 0x3e4d40
movq %rax, 0xc5251c(%rip)    # 0xe279e8
jmp 0x1d54d8
movq $0x0, -0x8(%rbp)
jmp 0x1d54fb
jmp 0x1d54da
jmp 0x1d54dc
movq 0xc52505(%rip), %rax    # 0xe279e8
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_table_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_scan_profile_16_pointer = parasail_sg_stats_table_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_profile_16_pointer = parasail_sg_stats_table_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_profile_16_pointer = parasail_sg_stats_table_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_profile_16_pointer = parasail_sg_stats_table_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_profile_16_pointer = parasail_sg_stats_table_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x1d5546
leaq 0x856443(%rip), %rax    # 0xa2b980
movq %rax, 0xc524ac(%rip)    # 0xe279f0
jmp 0x1d558c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5562
leaq 0x4f9f97(%rip), %rax    # 0x6cf4f0
movq %rax, 0xc52490(%rip)    # 0xe279f0
jmp 0x1d558a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d557e
leaq 0x21a26b(%rip), %rax    # 0x3ef7e0
movq %rax, 0xc52474(%rip)    # 0xe279f0
jmp 0x1d5588
movq $0x0, -0x8(%rbp)
jmp 0x1d55ab
jmp 0x1d558a
jmp 0x1d558c
movq 0xc5245d(%rip), %rax    # 0xe279f0
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_table_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_scan_profile_8_pointer = parasail_sg_stats_table_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_profile_8_pointer = parasail_sg_stats_table_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_profile_8_pointer = parasail_sg_stats_table_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_profile_8_pointer = parasail_sg_stats_table_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_profile_8_pointer = parasail_sg_stats_table_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x1d55f6
leaq 0x868a23(%rip), %rax    # 0xa3e010
movq %rax, 0xc52404(%rip)    # 0xe279f8
jmp 0x1d563c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5612
leaq 0x506647(%rip), %rax    # 0x6dbc50
movq %rax, 0xc523e8(%rip)    # 0xe279f8
jmp 0x1d563a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d562e
leaq 0x225dbb(%rip), %rax    # 0x3fb3e0
movq %rax, 0xc523cc(%rip)    # 0xe279f8
jmp 0x1d5638
movq $0x0, -0x8(%rbp)
jmp 0x1d565b
jmp 0x1d563a
jmp 0x1d563c
movq 0xc523b5(%rip), %rax    # 0xe279f8
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_table_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_striped_profile_64_pointer = parasail_sg_stats_table_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_profile_64_pointer = parasail_sg_stats_table_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_profile_64_pointer = parasail_sg_stats_table_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_profile_64_pointer = parasail_sg_stats_table_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_profile_64_pointer = parasail_sg_stats_table_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x1d56a6
leaq 0x8c0323(%rip), %rax    # 0xa959c0
movq %rax, 0xc5235c(%rip)    # 0xe27a00
jmp 0x1d56ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d56c2
leaq 0x5420f7(%rip), %rax    # 0x7177b0
movq %rax, 0xc52340(%rip)    # 0xe27a00
jmp 0x1d56ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d56de
leaq 0x25fd0b(%rip), %rax    # 0x4353e0
movq %rax, 0xc52324(%rip)    # 0xe27a00
jmp 0x1d56e8
movq $0x0, -0x8(%rbp)
jmp 0x1d570b
jmp 0x1d56ea
jmp 0x1d56ec
movq 0xc5230d(%rip), %rax    # 0xe27a00
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_table_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_table_striped_profile_32_pointer = parasail_sg_stats_table_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_profile_32_pointer = parasail_sg_stats_table_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_profile_32_pointer = parasail_sg_stats_table_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_profile_32_pointer = parasail_sg_stats_table_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_profile_32_pointer = parasail_sg_stats_table_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_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 0x1d5756
leaq 0x8cbb93(%rip), %rax    # 0xaa12e0
movq %rax, 0xc522b4(%rip)    # 0xe27a08
jmp 0x1d579c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5772
leaq 0x54bb57(%rip), %rax    # 0x7212c0
movq %rax, 0xc52298(%rip)    # 0xe27a08
jmp 0x1d579a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d578e
leaq 0x26913b(%rip), %rax    # 0x43e8c0
movq %rax, 0xc5227c(%rip)    # 0xe27a08
jmp 0x1d5798
movq $0x0, -0x8(%rbp)
jmp 0x1d57bb
jmp 0x1d579a
jmp 0x1d579c
movq 0xc52265(%rip), %rax    # 0xe27a08
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_table_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_stats_table_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_table_striped_profile_16_pointer = parasail_sg_stats_table_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_profile_16_pointer = parasail_sg_stats_table_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_profile_16_pointer = parasail_sg_stats_table_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_profile_16_pointer = parasail_sg_stats_table_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_profile_16_pointer = parasail_sg_stats_table_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_table_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 0x1d5806
leaq 0x8d8583(%rip), %rax    # 0xaadd80
movq %rax, 0xc5220c(%rip)    # 0xe27a10
jmp 0x1d584c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5822
leaq 0x555d97(%rip), %rax    # 0x72b5b0
movq %rax, 0xc521f0(%rip)    # 0xe27a10
jmp 0x1d584a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d583e
leaq 0x272b5b(%rip), %rax    # 0x448390
movq %rax, 0xc521d4(%rip)    # 0xe27a10
jmp 0x1d5848
movq $0x0, -0x8(%rbp)
jmp 0x1d586b
jmp 0x1d584a
jmp 0x1d584c
movq 0xc521bd(%rip), %rax    # 0xe27a10
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_table_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_stats_table_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_table_striped_profile_8_pointer = parasail_sg_stats_table_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_profile_8_pointer = parasail_sg_stats_table_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_profile_8_pointer = parasail_sg_stats_table_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_profile_8_pointer = parasail_sg_stats_table_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_profile_8_pointer = parasail_sg_stats_table_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_table_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 0x1d58b6
leaq 0x8e7313(%rip), %rax    # 0xabcbc0
movq %rax, 0xc52164(%rip)    # 0xe27a18
jmp 0x1d58fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d58d2
leaq 0x561157(%rip), %rax    # 0x736a20
movq %rax, 0xc52148(%rip)    # 0xe27a18
jmp 0x1d58fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d58ee
leaq 0x27d75b(%rip), %rax    # 0x453040
movq %rax, 0xc5212c(%rip)    # 0xe27a18
jmp 0x1d58f8
movq $0x0, -0x8(%rbp)
jmp 0x1d591b
jmp 0x1d58fa
jmp 0x1d58fc
movq 0xc52115(%rip), %rax    # 0xe27a18
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_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_profile_64_pointer = parasail_sg_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_profile_64_pointer = parasail_sg_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_profile_64_pointer = parasail_sg_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_profile_64_pointer = parasail_sg_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_profile_64_pointer = parasail_sg_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5966
leaq 0x8f1123(%rip), %rax    # 0xac6a80
movq %rax, 0xc520bc(%rip)    # 0xe27a20
jmp 0x1d59ac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5982
leaq 0x568d87(%rip), %rax    # 0x73e700
movq %rax, 0xc520a0(%rip)    # 0xe27a20
jmp 0x1d59aa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d599e
leaq 0x28505b(%rip), %rax    # 0x45a9f0
movq %rax, 0xc52084(%rip)    # 0xe27a20
jmp 0x1d59a8
movq $0x0, -0x8(%rbp)
jmp 0x1d59cb
jmp 0x1d59aa
jmp 0x1d59ac
movq 0xc5206d(%rip), %rax    # 0xe27a20
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_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_profile_32_pointer = parasail_sg_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_profile_32_pointer = parasail_sg_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_profile_32_pointer = parasail_sg_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_profile_32_pointer = parasail_sg_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_profile_32_pointer = parasail_sg_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5a16
leaq 0x8f7c43(%rip), %rax    # 0xacd650
movq %rax, 0xc52014(%rip)    # 0xe27a28
jmp 0x1d5a5c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5a32
leaq 0x56e427(%rip), %rax    # 0x743e50
movq %rax, 0xc51ff8(%rip)    # 0xe27a28
jmp 0x1d5a5a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5a4e
leaq 0x28a99b(%rip), %rax    # 0x4603e0
movq %rax, 0xc51fdc(%rip)    # 0xe27a28
jmp 0x1d5a58
movq $0x0, -0x8(%rbp)
jmp 0x1d5a7b
jmp 0x1d5a5a
jmp 0x1d5a5c
movq 0xc51fc5(%rip), %rax    # 0xe27a28
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_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_profile_16_pointer = parasail_sg_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_profile_16_pointer = parasail_sg_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_profile_16_pointer = parasail_sg_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_profile_16_pointer = parasail_sg_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_profile_16_pointer = parasail_sg_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5ac6
leaq 0x8ff983(%rip), %rax    # 0xad5440
movq %rax, 0xc51f6c(%rip)    # 0xe27a30
jmp 0x1d5b0c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5ae2
leaq 0x574167(%rip), %rax    # 0x749c40
movq %rax, 0xc51f50(%rip)    # 0xe27a30
jmp 0x1d5b0a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5afe
leaq 0x29085b(%rip), %rax    # 0x466350
movq %rax, 0xc51f34(%rip)    # 0xe27a30
jmp 0x1d5b08
movq $0x0, -0x8(%rbp)
jmp 0x1d5b2b
jmp 0x1d5b0a
jmp 0x1d5b0c
movq 0xc51f1d(%rip), %rax    # 0xe27a30
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_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_rowcol_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_scan_profile_8_pointer = parasail_sg_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_scan_profile_8_pointer = parasail_sg_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_scan_profile_8_pointer = parasail_sg_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_scan_profile_8_pointer = parasail_sg_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_scan_profile_8_pointer = parasail_sg_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5b76
leaq 0x9098c3(%rip), %rax    # 0xadf430
movq %rax, 0xc51ec4(%rip)    # 0xe27a38
jmp 0x1d5bbc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5b92
leaq 0x57a9d7(%rip), %rax    # 0x750560
movq %rax, 0xc51ea8(%rip)    # 0xe27a38
jmp 0x1d5bba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5bae
leaq 0x2973eb(%rip), %rax    # 0x46cf90
movq %rax, 0xc51e8c(%rip)    # 0xe27a38
jmp 0x1d5bb8
movq $0x0, -0x8(%rbp)
jmp 0x1d5bdb
jmp 0x1d5bba
jmp 0x1d5bbc
movq 0xc51e75(%rip), %rax    # 0xe27a38
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_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_profile_64_pointer = parasail_sg_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_profile_64_pointer = parasail_sg_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_profile_64_pointer = parasail_sg_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_profile_64_pointer = parasail_sg_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_profile_64_pointer = parasail_sg_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5c26
leaq 0x946833(%rip), %rax    # 0xb1c450
movq %rax, 0xc51e1c(%rip)    # 0xe27a40
jmp 0x1d5c6c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5c42
leaq 0x5a1677(%rip), %rax    # 0x7772b0
movq %rax, 0xc51e00(%rip)    # 0xe27a40
jmp 0x1d5c6a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5c5e
leaq 0x2bf1cb(%rip), %rax    # 0x494e20
movq %rax, 0xc51de4(%rip)    # 0xe27a40
jmp 0x1d5c68
movq $0x0, -0x8(%rbp)
jmp 0x1d5c8b
jmp 0x1d5c6a
jmp 0x1d5c6c
movq 0xc51dcd(%rip), %rax    # 0xe27a40
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_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_profile_32_pointer = parasail_sg_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_profile_32_pointer = parasail_sg_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_profile_32_pointer = parasail_sg_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_profile_32_pointer = parasail_sg_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_profile_32_pointer = parasail_sg_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5cd6
leaq 0x94c4a3(%rip), %rax    # 0xb22170
movq %rax, 0xc51d74(%rip)    # 0xe27a48
jmp 0x1d5d1c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5cf2
leaq 0x5a64e7(%rip), %rax    # 0x77c1d0
movq %rax, 0xc51d58(%rip)    # 0xe27a48
jmp 0x1d5d1a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5d0e
leaq 0x2c427b(%rip), %rax    # 0x499f80
movq %rax, 0xc51d3c(%rip)    # 0xe27a48
jmp 0x1d5d18
movq $0x0, -0x8(%rbp)
jmp 0x1d5d3b
jmp 0x1d5d1a
jmp 0x1d5d1c
movq 0xc51d25(%rip), %rax    # 0xe27a48
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_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_profile_16_pointer = parasail_sg_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_profile_16_pointer = parasail_sg_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_profile_16_pointer = parasail_sg_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_profile_16_pointer = parasail_sg_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_profile_16_pointer = parasail_sg_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5d86
leaq 0x952e23(%rip), %rax    # 0xb28ba0
movq %rax, 0xc51ccc(%rip)    # 0xe27a50
jmp 0x1d5dcc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5da2
leaq 0x5ab8e7(%rip), %rax    # 0x781680
movq %rax, 0xc51cb0(%rip)    # 0xe27a50
jmp 0x1d5dca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5dbe
leaq 0x2c978b(%rip), %rax    # 0x49f540
movq %rax, 0xc51c94(%rip)    # 0xe27a50
jmp 0x1d5dc8
movq $0x0, -0x8(%rbp)
jmp 0x1d5deb
jmp 0x1d5dca
jmp 0x1d5dcc
movq 0xc51c7d(%rip), %rax    # 0xe27a50
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_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_rowcol_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_rowcol_striped_profile_8_pointer = parasail_sg_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_rowcol_striped_profile_8_pointer = parasail_sg_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_rowcol_striped_profile_8_pointer = parasail_sg_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_rowcol_striped_profile_8_pointer = parasail_sg_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_rowcol_striped_profile_8_pointer = parasail_sg_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_rowcol_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 0x1d5e36
leaq 0x95b263(%rip), %rax    # 0xb31090
movq %rax, 0xc51c24(%rip)    # 0xe27a58
jmp 0x1d5e7c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5e52
leaq 0x5b1897(%rip), %rax    # 0x7876e0
movq %rax, 0xc51c08(%rip)    # 0xe27a58
jmp 0x1d5e7a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5e6e
leaq 0x2cfa4b(%rip), %rax    # 0x4a58b0
movq %rax, 0xc51bec(%rip)    # 0xe27a58
jmp 0x1d5e78
movq $0x0, -0x8(%rbp)
jmp 0x1d5e9b
jmp 0x1d5e7a
jmp 0x1d5e7c
movq 0xc51bd5(%rip), %rax    # 0xe27a58
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_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_profile_64_pointer = parasail_sg_stats_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_profile_64_pointer = parasail_sg_stats_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_profile_64_pointer = parasail_sg_stats_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_profile_64_pointer = parasail_sg_stats_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_profile_64_pointer = parasail_sg_stats_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_rowcol_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 0x1d5ee6
leaq 0x967433(%rip), %rax    # 0xb3d310
movq %rax, 0xc51b7c(%rip)    # 0xe27a60
jmp 0x1d5f2c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5f02
leaq 0x5bce27(%rip), %rax    # 0x792d20
movq %rax, 0xc51b60(%rip)    # 0xe27a60
jmp 0x1d5f2a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5f1e
leaq 0x2d8d2b(%rip), %rax    # 0x4aec40
movq %rax, 0xc51b44(%rip)    # 0xe27a60
jmp 0x1d5f28
movq $0x0, -0x8(%rbp)
jmp 0x1d5f4b
jmp 0x1d5f2a
jmp 0x1d5f2c
movq 0xc51b2d(%rip), %rax    # 0xe27a60
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_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_stats_rowcol_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_rowcol_scan_profile_32_pointer = parasail_sg_stats_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_rowcol_scan_profile_32_pointer = parasail_sg_stats_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_rowcol_scan_profile_32_pointer = parasail_sg_stats_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_rowcol_scan_profile_32_pointer = parasail_sg_stats_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_rowcol_scan_profile_32_pointer = parasail_sg_stats_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_stats_rowcol_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 0x1d5f96
leaq 0x9754b3(%rip), %rax    # 0xb4b440
movq %rax, 0xc51ad4(%rip)    # 0xe27a68
jmp 0x1d5fdc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1d5fb2
leaq 0x5c82f7(%rip), %rax    # 0x79e2a0
movq %rax, 0xc51ab8(%rip)    # 0xe27a68
jmp 0x1d5fda
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1d5fce
leaq 0x2e35db(%rip), %rax    # 0x4b95a0
movq %rax, 0xc51a9c(%rip)    # 0xe27a68
jmp 0x1d5fd8
movq $0x0, -0x8(%rbp)
jmp 0x1d5ffb
jmp 0x1d5fda
jmp 0x1d5fdc
movq 0xc51a85(%rip), %rax    # 0xe27a68
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)