LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_rowcol_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_rowcol_striped_profile_8_pointer = parasail_sw_stats_rowcol_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_stats_rowcol_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb60c
leaq 0x38914a(%rip), %rax    # 0x544754
jmp 0x1bb632
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb620
leaq 0x279f56(%rip), %rax    # 0x435574
jmp 0x1bb632
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb651
leaq 0x183d46(%rip), %rax    # 0x33f378
movq %rax, 0x5808bf(%rip)    # 0x73bef8
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_64_pointer = parasail_sw_trace_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb686
leaq 0x38c0d3(%rip), %rax    # 0x547757
jmp 0x1bb6ac
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb69a
leaq 0x27ccab(%rip), %rax    # 0x438343
jmp 0x1bb6ac
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb6cb
leaq 0x18725b(%rip), %rax    # 0x342907
movq %rax, 0x58084d(%rip)    # 0x73bf00
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_32_pointer = parasail_sw_trace_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb700
leaq 0x38dfa9(%rip), %rax    # 0x5496a7
jmp 0x1bb726
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb714
leaq 0x27eb4d(%rip), %rax    # 0x43a25f
jmp 0x1bb726
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb745
leaq 0x1895d9(%rip), %rax    # 0x344cff
movq %rax, 0x5807db(%rip)    # 0x73bf08
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_16_pointer = parasail_sw_trace_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb77a
leaq 0x38fd3f(%rip), %rax    # 0x54b4b7
jmp 0x1bb7a0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb78e
leaq 0x280977(%rip), %rax    # 0x43c103
jmp 0x1bb7a0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb7bf
leaq 0x18b56b(%rip), %rax    # 0x346d0b
movq %rax, 0x580769(%rip)    # 0x73bf10
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_scan_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_scan_profile_8_pointer = parasail_sw_trace_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_scan_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb7f4
leaq 0x391ab1(%rip), %rax    # 0x54d2a3
jmp 0x1bb81a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb808
leaq 0x282799(%rip), %rax    # 0x43df9f
jmp 0x1bb81a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb839
leaq 0x18d68d(%rip), %rax    # 0x348ea7
movq %rax, 0x5806f7(%rip)    # 0x73bf18
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_64_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_64_pointer = parasail_sw_trace_striped_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_64_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb86e
leaq 0x3a3d7b(%rip), %rax    # 0x55f5e7
jmp 0x1bb894
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb882
leaq 0x2902f7(%rip), %rax    # 0x44bb77
jmp 0x1bb894
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb8b3
leaq 0x19cbfb(%rip), %rax    # 0x35848f
movq %rax, 0x580685(%rip)    # 0x73bf20
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_32_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_32_pointer = parasail_sw_trace_striped_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_32_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb8e8
leaq 0x3a64d9(%rip), %rax    # 0x561dbf
jmp 0x1bb90e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb8fc
leaq 0x292a01(%rip), %rax    # 0x44e2fb
jmp 0x1bb90e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb92d
leaq 0x19f9ad(%rip), %rax    # 0x35b2bb
movq %rax, 0x580613(%rip)    # 0x73bf28
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_16_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_16_pointer = parasail_sw_trace_striped_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_16_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb962
leaq 0x3a89c7(%rip), %rax    # 0x564327
jmp 0x1bb988
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb976
leaq 0x294edf(%rip), %rax    # 0x450853
jmp 0x1bb988
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bb9a7
leaq 0x1a202b(%rip), %rax    # 0x35d9b3
movq %rax, 0x5805a1(%rip)    # 0x73bf30
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_trace_striped_profile_8_dispatcher
parasail_result_t* parasail_sw_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_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_trace_striped_profile_8_pointer = parasail_sw_trace_striped_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sw_trace_striped_profile_8_pointer(profile, s2, s2Len, open, gap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bb9dc
leaq 0x3aaea1(%rip), %rax    # 0x56687b
jmp 0x1bba02
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bb9f0
leaq 0x2973f1(%rip), %rax    # 0x452ddf
jmp 0x1bba02
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
je 0x1bba21
leaq 0x1a48e9(%rip), %rax    # 0x3602eb
movq %rax, 0x58052f(%rip)    # 0x73bf38
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_scan_64_pointer = parasail_sg_qb_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bbf49
leaq 0x298e27(%rip), %rax    # 0x454d6e
jmp 0x1bbf78
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bbf5d
leaq 0x1a6136(%rip), %rax    # 0x362091
jmp 0x1bbf78
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bbf71
leaq 0x8193f(%rip), %rax     # 0x23d8ae
jmp 0x1bbf78
leaq 0x950a8(%rip), %rax     # 0x251020
movq %rax, 0x57ffc1(%rip)    # 0x73bf40
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_scan_32_pointer = parasail_sg_qb_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bbfd2
leaq 0x29aa13(%rip), %rax    # 0x4569e3
jmp 0x1bc001
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bbfe6
leaq 0x1a7c42(%rip), %rax    # 0x363c26
jmp 0x1bc001
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bbffa
leaq 0x818b6(%rip), %rax     # 0x23d8ae
jmp 0x1bc001
leaq 0x9702e(%rip), %rax     # 0x25302f
movq %rax, 0x57ff40(%rip)    # 0x73bf48
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_scan_16_pointer = parasail_sg_qb_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc05b
leaq 0x29c506(%rip), %rax    # 0x45855f
jmp 0x1bc08a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc06f
leaq 0x1a9744(%rip), %rax    # 0x3657b1
jmp 0x1bc08a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc083
leaq 0x8182d(%rip), %rax     # 0x23d8ae
jmp 0x1bc08a
leaq 0x98ca1(%rip), %rax     # 0x254d2b
movq %rax, 0x57febf(%rip)    # 0x73bf50
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc0e4
leaq 0x29dfea(%rip), %rax    # 0x45a0cc
jmp 0x1bc113
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc0f8
leaq 0x1ab24f(%rip), %rax    # 0x367345
jmp 0x1bc113
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc10c
leaq 0x817a4(%rip), %rax     # 0x23d8ae
jmp 0x1bc113
leaq 0x9aaa9(%rip), %rax     # 0x256bbc
movq %rax, 0x57fe3e(%rip)    # 0x73bf58
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc16d
leaq 0x2a9bc5(%rip), %rax    # 0x465d30
jmp 0x1bc19c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc181
leaq 0x1b4e73(%rip), %rax    # 0x370ff2
jmp 0x1bc19c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc195
leaq 0x806ad(%rip), %rax     # 0x23c840
jmp 0x1bc19c
leaq 0xa63a4(%rip), %rax     # 0x262540
movq %rax, 0x57fdbd(%rip)    # 0x73bf60
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc1f6
leaq 0x2ab5b6(%rip), %rax    # 0x4677aa
jmp 0x1bc225
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc20a
leaq 0x1b67d9(%rip), %rax    # 0x3729e1
jmp 0x1bc225
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc21e
leaq 0x80624(%rip), %rax     # 0x23c840
jmp 0x1bc225
leaq 0xa8171(%rip), %rax     # 0x264396
movq %rax, 0x57fd3c(%rip)    # 0x73bf68
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc27f
leaq 0x2acec3(%rip), %rax    # 0x469140
jmp 0x1bc2ae
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc293
leaq 0x1b80bd(%rip), %rax    # 0x37434e
jmp 0x1bc2ae
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc2a7
leaq 0x8059b(%rip), %rax     # 0x23c840
jmp 0x1bc2ae
leaq 0xa9b53(%rip), %rax     # 0x265e01
movq %rax, 0x57fcbb(%rip)    # 0x73bf70
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc308
leaq 0x2ae7c6(%rip), %rax    # 0x46aacc
jmp 0x1bc337
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc31c
leaq 0x1b9991(%rip), %rax    # 0x375cab
jmp 0x1bc337
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc330
leaq 0x80512(%rip), %rax     # 0x23c840
jmp 0x1bc337
leaq 0xab72e(%rip), %rax     # 0x267a65
movq %rax, 0x57fc3a(%rip)    # 0x73bf78
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc391
leaq 0x29fdb7(%rip), %rax    # 0x45c146
jmp 0x1bc3c0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc3a5
leaq 0x1acd47(%rip), %rax    # 0x3690ea
jmp 0x1bc3c0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc3b9
leaq 0x80489(%rip), %rax     # 0x23c840
jmp 0x1bc3c0
leaq 0x9cc52(%rip), %rax     # 0x259012
movq %rax, 0x57fbb9(%rip)    # 0x73bf80
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc41a
leaq 0x2a1cc0(%rip), %rax    # 0x45e0d8
jmp 0x1bc449
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc42e
leaq 0x1ae827(%rip), %rax    # 0x36ac53
jmp 0x1bc449
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc442
leaq 0x80400(%rip), %rax     # 0x23c840
jmp 0x1bc449
leaq 0x9eb8c(%rip), %rax     # 0x25afd5
movq %rax, 0x57fb38(%rip)    # 0x73bf88
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc4a3
leaq 0x2a41a0(%rip), %rax    # 0x460641
jmp 0x1bc4d2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc4b7
leaq 0x1b0485(%rip), %rax    # 0x36c93a
jmp 0x1bc4d2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc4cb
leaq 0x80377(%rip), %rax     # 0x23c840
jmp 0x1bc4d2
leaq 0xa0b0c(%rip), %rax     # 0x25cfde
movq %rax, 0x57fab7(%rip)    # 0x73bf90
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc52c
leaq 0x2a71ad(%rip), %rax    # 0x4636d7
jmp 0x1bc55b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc540
leaq 0x1b2866(%rip), %rax    # 0x36eda4
jmp 0x1bc55b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc554
leaq 0x802ee(%rip), %rax     # 0x23c840
jmp 0x1bc55b
leaq 0xa36b8(%rip), %rax     # 0x25fc13
movq %rax, 0x57fa36(%rip)    # 0x73bf98
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc5b5
leaq 0x2b1b5c(%rip), %rax    # 0x46e10f
jmp 0x1bc5e4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc5c9
leaq 0x1bd193(%rip), %rax    # 0x37975a
jmp 0x1bc5e4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc5dd
leaq 0x812d3(%rip), %rax     # 0x23d8ae
jmp 0x1bc5e4
leaq 0xaf233(%rip), %rax     # 0x26b817
movq %rax, 0x57f9b5(%rip)    # 0x73bfa0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1bc63e
leaq 0x2b527c(%rip), %rax    # 0x4718b8
jmp 0x1bc66d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bc652
leaq 0x1c07b5(%rip), %rax    # 0x37ce05
jmp 0x1bc66d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bc666
leaq 0x8124a(%rip), %rax     # 0x23d8ae
jmp 0x1bc66d
leaq 0xb318b(%rip), %rax     # 0x26f7f8
movq %rax, 0x57f934(%rip)    # 0x73bfa8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax