LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_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_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x224f67
leaq 0x34a719(%rip), %rax    # 0x56f67e
jmp 0x224f96
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224f7b
leaq 0x2405cd(%rip), %rax    # 0x465546
jmp 0x224f96
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224f8f
leaq 0x74b45(%rip), %rax     # 0x299ad2
jmp 0x224f96
leaq 0x15a83a(%rip), %rax    # 0x37f7d0
movq %rax, 0x57ea73(%rip)    # 0x7a3a10
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_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_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x224ff0
leaq 0x34e529(%rip), %rax    # 0x573517
jmp 0x22501f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225004
leaq 0x2443ef(%rip), %rax    # 0x4693f1
jmp 0x22501f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x225018
leaq 0x74abc(%rip), %rax     # 0x299ad2
jmp 0x22501f
leaq 0x15eabc(%rip), %rax    # 0x383adb
movq %rax, 0x57e9f2(%rip)    # 0x7a3a18
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_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_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x225079
leaq 0x32d0e9(%rip), %rax    # 0x552160
jmp 0x2250a8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22508d
leaq 0x2284de(%rip), %rax    # 0x44d569
jmp 0x2250a8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2250a1
leaq 0x74a33(%rip), %rax     # 0x299ad2
jmp 0x2250a8
leaq 0x140783(%rip), %rax    # 0x36582b
movq %rax, 0x57e971(%rip)    # 0x7a3a20
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_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_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x225102
leaq 0x331694(%rip), %rax    # 0x556794
jmp 0x225131
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225116
leaq 0x22c2d5(%rip), %rax    # 0x4513e9
jmp 0x225131
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22512a
leaq 0x749aa(%rip), %rax     # 0x299ad2
jmp 0x225131
leaq 0x144a7a(%rip), %rax    # 0x369bab
movq %rax, 0x57e8f0(%rip)    # 0x7a3a28
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_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_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x22518b
leaq 0x33681e(%rip), %rax    # 0x55b9a7
jmp 0x2251ba
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22519f
leaq 0x230693(%rip), %rax    # 0x455830
jmp 0x2251ba
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2251b3
leaq 0x74921(%rip), %rax     # 0x299ad2
jmp 0x2251ba
leaq 0x149080(%rip), %rax    # 0x36e23a
movq %rax, 0x57e86f(%rip)    # 0x7a3a30
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_stats_rowcol_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_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_rowcol_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_stats_rowcol_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 0x594f9c
testl %eax, %eax
je 0x225214
leaq 0x33dca2(%rip), %rax    # 0x562eb4
jmp 0x225243
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225228
leaq 0x2359b6(%rip), %rax    # 0x45abdc
jmp 0x225243
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22523c
leaq 0x74898(%rip), %rax     # 0x299ad2
jmp 0x225243
leaq 0x14ea2f(%rip), %rax    # 0x373c72
movq %rax, 0x57e7ee(%rip)    # 0x7a3a38
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x22529d
leaq 0x351531(%rip), %rax    # 0x5767cc
jmp 0x2252cc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2252b1
leaq 0x246dd1(%rip), %rax    # 0x46c080
jmp 0x2252cc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2252c5
leaq 0x7568d(%rip), %rax     # 0x29a950
jmp 0x2252cc
leaq 0x161817(%rip), %rax    # 0x386ae3
movq %rax, 0x57e76d(%rip)    # 0x7a3a40
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x225326
leaq 0x35342f(%rip), %rax    # 0x578753
jmp 0x225355
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22533a
leaq 0x248914(%rip), %rax    # 0x46dc4c
jmp 0x225355
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22534e
leaq 0x75604(%rip), %rax     # 0x29a950
jmp 0x225355
leaq 0x163638(%rip), %rax    # 0x38898d
movq %rax, 0x57e6ec(%rip)    # 0x7a3a48
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x2253af
leaq 0x354e65(%rip), %rax    # 0x57a212
jmp 0x2253de
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2253c3
leaq 0x24a2b4(%rip), %rax    # 0x46f675
jmp 0x2253de
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2253d7
leaq 0x7557b(%rip), %rax     # 0x29a950
jmp 0x2253de
leaq 0x165160(%rip), %rax    # 0x38a53e
movq %rax, 0x57e66b(%rip)    # 0x7a3a50
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_trace_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x225438
leaq 0x35687d(%rip), %rax    # 0x57bcb3
jmp 0x225467
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22544c
leaq 0x24bc7d(%rip), %rax    # 0x4710c7
jmp 0x225467
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x225460
leaq 0x754f2(%rip), %rax     # 0x29a950
jmp 0x225467
leaq 0x166de7(%rip), %rax    # 0x38c24e
movq %rax, 0x57e5ea(%rip)    # 0x7a3a58
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_striped_64_pointer = parasail_sg_qx_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_64_pointer = parasail_sg_qx_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_64_pointer = parasail_sg_qx_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_64_pointer = parasail_sg_qx_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_64_pointer = parasail_sg_qx_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_trace_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x2254c1
leaq 0x368554(%rip), %rax    # 0x58da13
jmp 0x2254f0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2254d5
leaq 0x258640(%rip), %rax    # 0x47db13
jmp 0x2254f0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2254e9
leaq 0x745eb(%rip), %rax     # 0x299ad2
jmp 0x2254f0
leaq 0x174c5c(%rip), %rax    # 0x39a14c
movq %rax, 0x57e569(%rip)    # 0x7a3a60
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_trace_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x22554a
leaq 0x36aa9f(%rip), %rax    # 0x58ffe7
jmp 0x225579
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22555e
leaq 0x25a974(%rip), %rax    # 0x47fed0
jmp 0x225579
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x225572
leaq 0x74562(%rip), %rax     # 0x299ad2
jmp 0x225579
leaq 0x17733c(%rip), %rax    # 0x39c8b5
movq %rax, 0x57e4e8(%rip)    # 0x7a3a68
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_trace_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x2255d3
leaq 0x36cb80(%rip), %rax    # 0x592151
jmp 0x225602
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2255e7
leaq 0x25c9f2(%rip), %rax    # 0x481fd7
jmp 0x225602
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2255fb
leaq 0x744d9(%rip), %rax     # 0x299ad2
jmp 0x225602
leaq 0x179502(%rip), %rax    # 0x39eb04
movq %rax, 0x57e467(%rip)    # 0x7a3a70
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_trace_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x22565c
leaq 0x36ec8f(%rip), %rax    # 0x5942e9
jmp 0x22568b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225670
leaq 0x25ea83(%rip), %rax    # 0x4840f1
jmp 0x22568b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x225684
leaq 0x74450(%rip), %rax     # 0x299ad2
jmp 0x22568b
leaq 0x17b8c3(%rip), %rax    # 0x3a0f4e
movq %rax, 0x57e3e6(%rip)    # 0x7a3a78
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x2256e5
leaq 0x358c55(%rip), %rax    # 0x57e338
jmp 0x225714
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2256f9
leaq 0x24d962(%rip), %rax    # 0x473059
jmp 0x225714
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22570d
leaq 0x743c7(%rip), %rax     # 0x299ad2
jmp 0x225714
leaq 0x168fcf(%rip), %rax    # 0x38e6e3
movq %rax, 0x57e365(%rip)    # 0x7a3a80
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x22576e
leaq 0x35b5c9(%rip), %rax    # 0x580d35
jmp 0x22579d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225782
leaq 0x24f8bd(%rip), %rax    # 0x47503d
jmp 0x22579d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x225796
leaq 0x7433e(%rip), %rax     # 0x299ad2
jmp 0x22579d
leaq 0x16b2c9(%rip), %rax    # 0x390a66
movq %rax, 0x57e2e4(%rip)    # 0x7a3a88
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x2257f7
leaq 0x35eb30(%rip), %rax    # 0x584325
jmp 0x225826
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22580b
leaq 0x251d75(%rip), %rax    # 0x47757e
jmp 0x225826
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22581f
leaq 0x742b5(%rip), %rax     # 0x299ad2
jmp 0x225826
leaq 0x16d9ce(%rip), %rax    # 0x3931f4
movq %rax, 0x57e263(%rip)    # 0x7a3a90
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_trace_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_trace_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_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx_trace_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_trace_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_trace_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 0x594f9c
testl %eax, %eax
je 0x225880
leaq 0x363fad(%rip), %rax    # 0x58982b
jmp 0x2258af
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225894
leaq 0x255148(%rip), %rax    # 0x47a9da
jmp 0x2258af
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2258a8
leaq 0x7422c(%rip), %rax     # 0x299ad2
jmp 0x2258af
leaq 0x1712fd(%rip), %rax    # 0x396bac
movq %rax, 0x57e1e2(%rip)    # 0x7a3a98
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_64_pointer = parasail_sg_qx_scan_profile_neon_128_64;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x225902
leaq 0x260d6c(%rip), %rax    # 0x48666c
jmp 0x225928
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225916
leaq 0x17d54d(%rip), %rax    # 0x3a2e61
jmp 0x225928
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x225947
leaq 0x8672e(%rip), %rax     # 0x2ac056
movq %rax, 0x57e171(%rip)    # 0x7a3aa0
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_32_pointer = parasail_sg_qx_scan_profile_neon_128_32;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22597c
leaq 0x262838(%rip), %rax    # 0x4881b2
jmp 0x2259a2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225990
leaq 0x17ecfe(%rip), %rax    # 0x3a468c
jmp 0x2259a2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x2259c1
leaq 0x8811c(%rip), %rax     # 0x2adabe
movq %rax, 0x57e0ff(%rip)    # 0x7a3aa8
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_16_pointer = parasail_sg_qx_scan_profile_neon_128_16;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2259f6
leaq 0x263ead(%rip), %rax    # 0x4898a1
jmp 0x225a1c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225a0a
leaq 0x180357(%rip), %rax    # 0x3a5d5f
jmp 0x225a1c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x225a3b
leaq 0x8987b(%rip), %rax     # 0x2af297
movq %rax, 0x57e08d(%rip)    # 0x7a3ab0
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_scan_profile_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_scan_profile_8_pointer = parasail_sg_qx_scan_profile_neon_128_8;
    }
    else
#endif
    {
        /* no fallback; caller must check for non-NULL result */
        return NULL;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x225a70
leaq 0x2654f9(%rip), %rax    # 0x48af67
jmp 0x225a96
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x225a84
leaq 0x18199f(%rip), %rax    # 0x3a7421
jmp 0x225a96
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
je 0x225ab5
leaq 0x8b18e(%rip), %rax     # 0x2b0c24
movq %rax, 0x57e01b(%rip)    # 0x7a3ab8
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