LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_profile_8_pointer = parasail_sg_qb_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e79b6
leaq 0x949323(%rip), %rax    # 0xb30cd0
movq %rax, 0xc40964(%rip)    # 0xe28318
jmp 0x1e79fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e79d2
leaq 0x59f957(%rip), %rax    # 0x787320
movq %rax, 0xc40948(%rip)    # 0xe28318
jmp 0x1e79fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e79ee
leaq 0x2bdb0b(%rip), %rax    # 0x4a54f0
movq %rax, 0xc4092c(%rip)    # 0xe28318
jmp 0x1e79f8
movq $0x0, -0x8(%rbp)
jmp 0x1e7a1b
jmp 0x1e79fa
jmp 0x1e79fc
movq 0xc40915(%rip), %rax    # 0xe28318
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_profile_64_pointer = parasail_sg_qb_stats_rowcol_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_profile_64_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_64_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_profile_64_pointer = parasail_sg_qb_stats_rowcol_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_profile_64_pointer = parasail_sg_qb_stats_rowcol_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e7a66
leaq 0x9554f3(%rip), %rax    # 0xb3cf50
movq %rax, 0xc408bc(%rip)    # 0xe28320
jmp 0x1e7aac
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7a82
leaq 0x5aaee7(%rip), %rax    # 0x792960
movq %rax, 0xc408a0(%rip)    # 0xe28320
jmp 0x1e7aaa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7a9e
leaq 0x2c6deb(%rip), %rax    # 0x4ae880
movq %rax, 0xc40884(%rip)    # 0xe28320
jmp 0x1e7aa8
movq $0x0, -0x8(%rbp)
jmp 0x1e7acb
jmp 0x1e7aaa
jmp 0x1e7aac
movq 0xc4086d(%rip), %rax    # 0xe28320
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_scan_profile_32_pointer = parasail_sg_qb_stats_rowcol_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_profile_32_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_32_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_profile_32_pointer = parasail_sg_qb_stats_rowcol_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_profile_32_pointer = parasail_sg_qb_stats_rowcol_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_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 0x1e7b16
leaq 0x963573(%rip), %rax    # 0xb4b080
movq %rax, 0xc40814(%rip)    # 0xe28328
jmp 0x1e7b5c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7b32
leaq 0x5b63b7(%rip), %rax    # 0x79dee0
movq %rax, 0xc407f8(%rip)    # 0xe28328
jmp 0x1e7b5a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7b4e
leaq 0x2d169b(%rip), %rax    # 0x4b91e0
movq %rax, 0xc407dc(%rip)    # 0xe28328
jmp 0x1e7b58
movq $0x0, -0x8(%rbp)
jmp 0x1e7b7b
jmp 0x1e7b5a
jmp 0x1e7b5c
movq 0xc407c5(%rip), %rax    # 0xe28328
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_profile_16_pointer = parasail_sg_qb_stats_rowcol_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x1e7bc6
leaq 0x972f93(%rip), %rax    # 0xb5ab50
movq %rax, 0xc4076c(%rip)    # 0xe28330
jmp 0x1e7c0c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7be2
leaq 0x5c2137(%rip), %rax    # 0x7a9d10
movq %rax, 0xc40750(%rip)    # 0xe28330
jmp 0x1e7c0a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7bfe
leaq 0x2dc6bb(%rip), %rax    # 0x4c42b0
movq %rax, 0xc40734(%rip)    # 0xe28330
jmp 0x1e7c08
movq $0x0, -0x8(%rbp)
jmp 0x1e7c2b
jmp 0x1e7c0a
jmp 0x1e7c0c
movq 0xc4071d(%rip), %rax    # 0xe28330
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_profile_8_pointer = parasail_sg_qb_stats_rowcol_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x1e7c76
leaq 0x9858e3(%rip), %rax    # 0xb6d550
movq %rax, 0xc406c4(%rip)    # 0xe28338
jmp 0x1e7cbc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7c92
leaq 0x5cecd7(%rip), %rax    # 0x7b6960
movq %rax, 0xc406a8(%rip)    # 0xe28338
jmp 0x1e7cba
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7cae
leaq 0x2e86bb(%rip), %rax    # 0x4d0360
movq %rax, 0xc4068c(%rip)    # 0xe28338
jmp 0x1e7cb8
movq $0x0, -0x8(%rbp)
jmp 0x1e7cdb
jmp 0x1e7cba
jmp 0x1e7cbc
movq 0xc40675(%rip), %rax    # 0xe28338
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_64_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x1e7d26
leaq 0x9df4f3(%rip), %rax    # 0xbc7210
movq %rax, 0xc4061c(%rip)    # 0xe28340
jmp 0x1e7d6c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7d42
leaq 0x60ba17(%rip), %rax    # 0x7f3750
movq %rax, 0xc40600(%rip)    # 0xe28340
jmp 0x1e7d6a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7d5e
leaq 0x323abb(%rip), %rax    # 0x50b810
movq %rax, 0xc405e4(%rip)    # 0xe28340
jmp 0x1e7d68
movq $0x0, -0x8(%rbp)
jmp 0x1e7d8b
jmp 0x1e7d6a
jmp 0x1e7d6c
movq 0xc405cd(%rip), %rax    # 0xe28340
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_32_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x1e7dd6
leaq 0x9eb123(%rip), %rax    # 0xbd2ef0
movq %rax, 0xc40574(%rip)    # 0xe28348
jmp 0x1e7e1c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7df2
leaq 0x615827(%rip), %rax    # 0x7fd610
movq %rax, 0xc40558(%rip)    # 0xe28348
jmp 0x1e7e1a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7e0e
leaq 0x32d31b(%rip), %rax    # 0x515120
movq %rax, 0xc4053c(%rip)    # 0xe28348
jmp 0x1e7e18
movq $0x0, -0x8(%rbp)
jmp 0x1e7e3b
jmp 0x1e7e1a
jmp 0x1e7e1c
movq 0xc40525(%rip), %rax    # 0xe28348
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_16_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x1e7e86
leaq 0x9f7dc3(%rip), %rax    # 0xbdfc40
movq %rax, 0xc404cc(%rip)    # 0xe28350
jmp 0x1e7ecc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7ea2
leaq 0x61fdd7(%rip), %rax    # 0x807c70
movq %rax, 0xc404b0(%rip)    # 0xe28350
jmp 0x1e7eca
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7ebe
leaq 0x3370eb(%rip), %rax    # 0x51efa0
movq %rax, 0xc40494(%rip)    # 0xe28350
jmp 0x1e7ec8
movq $0x0, -0x8(%rbp)
jmp 0x1e7eeb
jmp 0x1e7eca
jmp 0x1e7ecc
movq 0xc4047d(%rip), %rax    # 0xe28350
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_profile_8_pointer = parasail_sg_qb_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_stats_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 0x1e7f36
leaq 0xa06b73(%rip), %rax    # 0xbeeaa0
movq %rax, 0xc40424(%rip)    # 0xe28358
jmp 0x1e7f7c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e7f52
leaq 0x62b3b7(%rip), %rax    # 0x813300
movq %rax, 0xc40408(%rip)    # 0xe28358
jmp 0x1e7f7a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e7f6e
leaq 0x341ecb(%rip), %rax    # 0x529e30
movq %rax, 0xc403ec(%rip)    # 0xe28358
jmp 0x1e7f78
movq $0x0, -0x8(%rbp)
jmp 0x1e7f9b
jmp 0x1e7f7a
jmp 0x1e7f7c
movq 0xc403d5(%rip), %rax    # 0xe28358
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_64_pointer = parasail_sg_qb_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e7fe6
leaq 0xa118e3(%rip), %rax    # 0xbf98c0
movq %rax, 0xc4037c(%rip)    # 0xe28360
jmp 0x1e802c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e8002
leaq 0x633bc7(%rip), %rax    # 0x81bbc0
movq %rax, 0xc40360(%rip)    # 0xe28360
jmp 0x1e802a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e801e
leaq 0x34a31b(%rip), %rax    # 0x532330
movq %rax, 0xc40344(%rip)    # 0xe28360
jmp 0x1e8028
movq $0x0, -0x8(%rbp)
jmp 0x1e804b
jmp 0x1e802a
jmp 0x1e802c
movq 0xc4032d(%rip), %rax    # 0xe28360
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_32_pointer = parasail_sg_qb_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e8096
leaq 0xa19f33(%rip), %rax    # 0xc01fc0
movq %rax, 0xc402d4(%rip)    # 0xe28368
jmp 0x1e80dc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e80b2
leaq 0x63a4c7(%rip), %rax    # 0x822570
movq %rax, 0xc402b8(%rip)    # 0xe28368
jmp 0x1e80da
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e80ce
leaq 0x350d0b(%rip), %rax    # 0x538dd0
movq %rax, 0xc4029c(%rip)    # 0xe28368
jmp 0x1e80d8
movq $0x0, -0x8(%rbp)
jmp 0x1e80fb
jmp 0x1e80da
jmp 0x1e80dc
movq 0xc40285(%rip), %rax    # 0xe28368
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_16_pointer = parasail_sg_qb_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e8146
leaq 0xa24043(%rip), %rax    # 0xc0c180
movq %rax, 0xc4022c(%rip)    # 0xe28370
jmp 0x1e818c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e8162
leaq 0x6418a7(%rip), %rax    # 0x829a00
movq %rax, 0xc40210(%rip)    # 0xe28370
jmp 0x1e818a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e817e
leaq 0x35829b(%rip), %rax    # 0x540410
movq %rax, 0xc401f4(%rip)    # 0xe28370
jmp 0x1e8188
movq $0x0, -0x8(%rbp)
jmp 0x1e81ab
jmp 0x1e818a
jmp 0x1e818c
movq 0xc401dd(%rip), %rax    # 0xe28370
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_profile_8_pointer = parasail_sg_qb_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e81f6
leaq 0xa313a3(%rip), %rax    # 0xc19590
movq %rax, 0xc40184(%rip)    # 0xe28378
jmp 0x1e823c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e8212
leaq 0x649f57(%rip), %rax    # 0x832160
movq %rax, 0xc40168(%rip)    # 0xe28378
jmp 0x1e823a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e822e
leaq 0x360d9b(%rip), %rax    # 0x548fc0
movq %rax, 0xc4014c(%rip)    # 0xe28378
jmp 0x1e8238
movq $0x0, -0x8(%rbp)
jmp 0x1e825b
jmp 0x1e823a
jmp 0x1e823c
movq 0xc40135(%rip), %rax    # 0xe28378
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_profile_64_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_64_pointer = parasail_sg_qb_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e82a6
leaq 0xa7ab23(%rip), %rax    # 0xc62dc0
movq %rax, 0xc400dc(%rip)    # 0xe28380
jmp 0x1e82ec
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e82c2
leaq 0x678957(%rip), %rax    # 0x860c10
movq %rax, 0xc400c0(%rip)    # 0xe28380
jmp 0x1e82ea
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e82de
leaq 0x39019b(%rip), %rax    # 0x578470
movq %rax, 0xc400a4(%rip)    # 0xe28380
jmp 0x1e82e8
movq $0x0, -0x8(%rbp)
jmp 0x1e830b
jmp 0x1e82ea
jmp 0x1e82ec
movq 0xc4008d(%rip), %rax    # 0xe28380
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_profile_32_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_32_pointer = parasail_sg_qb_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e8356
leaq 0xa84933(%rip), %rax    # 0xc6cc80
movq %rax, 0xc40034(%rip)    # 0xe28388
jmp 0x1e839c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e8372
leaq 0x6808e7(%rip), %rax    # 0x868c50
movq %rax, 0xc40018(%rip)    # 0xe28388
jmp 0x1e839a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e838e
leaq 0x3980db(%rip), %rax    # 0x580460
movq %rax, 0xc3fffc(%rip)    # 0xe28388
jmp 0x1e8398
movq $0x0, -0x8(%rbp)
jmp 0x1e83bb
jmp 0x1e839a
jmp 0x1e839c
movq 0xc3ffe5(%rip), %rax    # 0xe28388
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_profile_16_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_16_pointer = parasail_sg_qb_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e8406
leaq 0xa901b3(%rip), %rax    # 0xc785b0
movq %rax, 0xc3ff8c(%rip)    # 0xe28390
jmp 0x1e844c
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e8422
leaq 0x689557(%rip), %rax    # 0x871970
movq %rax, 0xc3ff70(%rip)    # 0xe28390
jmp 0x1e844a
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e843e
leaq 0x3a0d1b(%rip), %rax    # 0x589150
movq %rax, 0xc3ff54(%rip)    # 0xe28390
jmp 0x1e8448
movq $0x0, -0x8(%rbp)
jmp 0x1e846b
jmp 0x1e844a
jmp 0x1e844c
movq 0xc3ff3d(%rip), %rax    # 0xe28390
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_qb_dispatch.c
// Function: parasail_sg_qb_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_profile_8_dispatcher(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_profile_8_pointer = parasail_sg_qb_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qb_trace_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 0x1e84b6
leaq 0xa9e943(%rip), %rax    # 0xc86df0
movq %rax, 0xc3fee4(%rip)    # 0xe28398
jmp 0x1e84fc
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e84d2
leaq 0x693647(%rip), %rax    # 0x87bb10
movq %rax, 0xc3fec8(%rip)    # 0xe28398
jmp 0x1e84fa
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e84ee
leaq 0x3ab0cb(%rip), %rax    # 0x5935b0
movq %rax, 0xc3feac(%rip)    # 0xe28398
jmp 0x1e84f8
movq $0x0, -0x8(%rbp)
jmp 0x1e851b
jmp 0x1e84fa
jmp 0x1e84fc
movq 0xc3fe95(%rip), %rax    # 0xe28398
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_qe_dispatch.c
// Function: parasail_sg_qe_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eadae
leaq 0x6982eb(%rip), %rax    # 0x883090
movq %rax, 0xc3d5f4(%rip)    # 0xe283a0
jmp 0x1eadf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eadca
leaq 0x3af3bf(%rip), %rax    # 0x59a180
movq %rax, 0xc3d5d8(%rip)    # 0xe283a0
jmp 0x1eadf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eade6
leaq 0xd5463(%rip), %rax     # 0x2c0240
movq %rax, 0xc3d5bc(%rip)    # 0xe283a0
jmp 0x1eadf4
leaq 0xae4b3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3d5ac(%rip)    # 0xe283a0
jmp 0x1eadf6
jmp 0x1eadf8
movq 0xc3d5a1(%rip), %rax    # 0xe283a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%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_qe_dispatch.c
// Function: parasail_sg_qe_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eae6e
leaq 0x69e70b(%rip), %rax    # 0x889570
movq %rax, 0xc3d53c(%rip)    # 0xe283a8
jmp 0x1eaeb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eae8a
leaq 0x3b457f(%rip), %rax    # 0x59f400
movq %rax, 0xc3d520(%rip)    # 0xe283a8
jmp 0x1eaeb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eaea6
leaq 0xda803(%rip), %rax     # 0x2c56a0
movq %rax, 0xc3d504(%rip)    # 0xe283a8
jmp 0x1eaeb4
leaq 0xae3f3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3d4f4(%rip)    # 0xe283a8
jmp 0x1eaeb6
jmp 0x1eaeb8
movq 0xc3d4e9(%rip), %rax    # 0xe283a8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%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_qe_dispatch.c
// Function: parasail_sg_qe_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eaf2e
leaq 0x6a598b(%rip), %rax    # 0x8908b0
movq %rax, 0xc3d484(%rip)    # 0xe283b0
jmp 0x1eaf78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eaf4a
leaq 0x3b9c3f(%rip), %rax    # 0x5a4b80
movq %rax, 0xc3d468(%rip)    # 0xe283b0
jmp 0x1eaf76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eaf66
leaq 0xe0003(%rip), %rax     # 0x2caf60
movq %rax, 0xc3d44c(%rip)    # 0xe283b0
jmp 0x1eaf74
leaq 0xae333(%rip), %rax     # 0x2992a0
movq %rax, 0xc3d43c(%rip)    # 0xe283b0
jmp 0x1eaf76
jmp 0x1eaf78
movq 0xc3d431(%rip), %rax    # 0xe283b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)