LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1bde53
leaq 0x342337(%rip), %rax    # 0x500188
jmp 0x1bde82
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bde67
leaq 0x23bc2d(%rip), %rax    # 0x3f9a92
jmp 0x1bde82
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bde7b
leaq 0x7e9c7(%rip), %rax     # 0x23c840
jmp 0x1bde82
leaq 0x13ec15(%rip), %rax    # 0x2fca97
movq %rax, 0x57e287(%rip)    # 0x73c110
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_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1bdedc
leaq 0x348048(%rip), %rax    # 0x505f22
jmp 0x1bdf0b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdef0
leaq 0x23f423(%rip), %rax    # 0x3fd311
jmp 0x1bdf0b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdf04
leaq 0x7e93e(%rip), %rax     # 0x23c840
jmp 0x1bdf0b
leaq 0x142bb4(%rip), %rax    # 0x300abf
movq %rax, 0x57e206(%rip)    # 0x73c118
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_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_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_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_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 0x1bdf65
leaq 0x355872(%rip), %rax    # 0x5137d5
jmp 0x1bdf94
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdf79
leaq 0x24b770(%rip), %rax    # 0x4096e7
jmp 0x1bdf94
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdf8d
leaq 0x7f923(%rip), %rax     # 0x23d8ae
jmp 0x1bdf94
leaq 0x1500ee(%rip), %rax    # 0x30e082
movq %rax, 0x57e185(%rip)    # 0x73c120
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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_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_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_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 0x1bdfee
leaq 0x3597f4(%rip), %rax    # 0x5177e0
jmp 0x1be01d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be002
leaq 0x24f3aa(%rip), %rax    # 0x40d3aa
jmp 0x1be01d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be016
leaq 0x7f89a(%rip), %rax     # 0x23d8ae
jmp 0x1be01d
leaq 0x154688(%rip), %rax    # 0x3126a5
movq %rax, 0x57e104(%rip)    # 0x73c128
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_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_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_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_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 0x1be077
leaq 0x35d42a(%rip), %rax    # 0x51b49f
jmp 0x1be0a6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be08b
leaq 0x252e12(%rip), %rax    # 0x410e9b
jmp 0x1be0a6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be09f
leaq 0x7f811(%rip), %rax     # 0x23d8ae
jmp 0x1be0a6
leaq 0x158575(%rip), %rax    # 0x31661b
movq %rax, 0x57e083(%rip)    # 0x73c130
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_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_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_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_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 0x1be100
leaq 0x361452(%rip), %rax    # 0x51f550
jmp 0x1be12f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be114
leaq 0x256aa5(%rip), %rax    # 0x414bb7
jmp 0x1be12f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be128
leaq 0x7f788(%rip), %rax     # 0x23d8ae
jmp 0x1be12f
leaq 0x15c799(%rip), %rax    # 0x31a8c8
movq %rax, 0x57e002(%rip)    # 0x73c138
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_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_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_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_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 0x1be189
leaq 0x37ad19(%rip), %rax    # 0x538ea0
jmp 0x1be1b8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be19d
leaq 0x26c1ff(%rip), %rax    # 0x42a39a
jmp 0x1be1b8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be1b1
leaq 0x7e691(%rip), %rax     # 0x23c840
jmp 0x1be1b8
leaq 0x174df0(%rip), %rax    # 0x332fa8
movq %rax, 0x57df81(%rip)    # 0x73c140
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_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_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_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_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 0x1be212
leaq 0x37e7ba(%rip), %rax    # 0x53c9ca
jmp 0x1be241
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be226
leaq 0x26fbad(%rip), %rax    # 0x42ddd1
jmp 0x1be241
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be23a
leaq 0x7e608(%rip), %rax     # 0x23c840
jmp 0x1be241
leaq 0x179007(%rip), %rax    # 0x337248
movq %rax, 0x57df00(%rip)    # 0x73c148
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_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be29b
leaq 0x38214c(%rip), %rax    # 0x5403e5
jmp 0x1be2ca
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be2af
leaq 0x273370(%rip), %rax    # 0x43161d
jmp 0x1be2ca
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be2c3
leaq 0x7e57f(%rip), %rax     # 0x23c840
jmp 0x1be2ca
leaq 0x17cc7c(%rip), %rax    # 0x33af46
movq %rax, 0x57de7f(%rip)    # 0x73c150
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_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be324
leaq 0x385ff5(%rip), %rax    # 0x544317
jmp 0x1be353
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be338
leaq 0x276e00(%rip), %rax    # 0x435136
jmp 0x1be353
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be34c
leaq 0x7e4f6(%rip), %rax     # 0x23c840
jmp 0x1be353
leaq 0x180be5(%rip), %rax    # 0x33ef38
movq %rax, 0x57ddfe(%rip)    # 0x73c158
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_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be3ad
leaq 0x3654e4(%rip), %rax    # 0x52388f
jmp 0x1be3dc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be3c1
leaq 0x25a884(%rip), %rax    # 0x418c43
jmp 0x1be3dc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be3d5
leaq 0x7e46d(%rip), %rax     # 0x23c840
jmp 0x1be3dc
leaq 0x160f4f(%rip), %rax    # 0x31f32b
movq %rax, 0x57dd7d(%rip)    # 0x73c160
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_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be436
leaq 0x3695ba(%rip), %rax    # 0x5279ee
jmp 0x1be465
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be44a
leaq 0x25e416(%rip), %rax    # 0x41c85e
jmp 0x1be465
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be45e
leaq 0x7e3e4(%rip), %rax     # 0x23c840
jmp 0x1be465
leaq 0x16530a(%rip), %rax    # 0x32376f
movq %rax, 0x57dcfc(%rip)    # 0x73c168
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_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be4bf
leaq 0x36e795(%rip), %rax    # 0x52cc52
jmp 0x1be4ee
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be4d3
leaq 0x262570(%rip), %rax    # 0x420a41
jmp 0x1be4ee
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be4e7
leaq 0x7e35b(%rip), %rax     # 0x23c840
jmp 0x1be4ee
leaq 0x1698c0(%rip), %rax    # 0x327dae
movq %rax, 0x57dc7b(%rip)    # 0x73c170
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_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be548
leaq 0x37567e(%rip), %rax    # 0x533bc4
jmp 0x1be577
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be55c
leaq 0x26777f(%rip), %rax    # 0x425cd9
jmp 0x1be577
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be570
leaq 0x7e2d2(%rip), %rax     # 0x23c840
jmp 0x1be577
leaq 0x16f61b(%rip), %rax    # 0x32db92
movq %rax, 0x57dbfa(%rip)    # 0x73c178
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_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be5d1
leaq 0x388d73(%rip), %rax    # 0x547342
jmp 0x1be600
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be5e5
leaq 0x27994c(%rip), %rax    # 0x437f2f
jmp 0x1be600
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be5f9
leaq 0x7f2b7(%rip), %rax     # 0x23d8ae
jmp 0x1be600
leaq 0x183ef1(%rip), %rax    # 0x3424f1
movq %rax, 0x57db79(%rip)    # 0x73c180
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_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be65a
leaq 0x38ac39(%rip), %rax    # 0x549291
jmp 0x1be689
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be66e
leaq 0x27b7dd(%rip), %rax    # 0x439e49
jmp 0x1be689
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be682
leaq 0x7f22e(%rip), %rax     # 0x23d8ae
jmp 0x1be689
leaq 0x186261(%rip), %rax    # 0x3448ea
movq %rax, 0x57daf8(%rip)    # 0x73c188
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_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be6e3
leaq 0x38c9c1(%rip), %rax    # 0x54b0a2
jmp 0x1be712
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be6f7
leaq 0x27d5f7(%rip), %rax    # 0x43bcec
jmp 0x1be712
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be70b
leaq 0x7f1a5(%rip), %rax     # 0x23d8ae
jmp 0x1be712
leaq 0x1881e3(%rip), %rax    # 0x3468f5
movq %rax, 0x57da77(%rip)    # 0x73c190
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_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be76c
leaq 0x38e725(%rip), %rax    # 0x54ce8f
jmp 0x1be79b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be780
leaq 0x27f40a(%rip), %rax    # 0x43db88
jmp 0x1be79b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be794
leaq 0x7f11c(%rip), %rax     # 0x23d8ae
jmp 0x1be79b
leaq 0x18a2f5(%rip), %rax    # 0x348a90
movq %rax, 0x57d9f6(%rip)    # 0x73c198
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_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be7f5
leaq 0x3a09dd(%rip), %rax    # 0x55f1d0
jmp 0x1be824
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be809
leaq 0x28cf5c(%rip), %rax    # 0x44b763
jmp 0x1be824
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be81d
leaq 0x7e025(%rip), %rax     # 0x23c840
jmp 0x1be824
leaq 0x199856(%rip), %rax    # 0x35807a
movq %rax, 0x57d975(%rip)    # 0x73c1a0
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_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be87e
leaq 0x3a312c(%rip), %rax    # 0x5619a8
jmp 0x1be8ad
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be892
leaq 0x28f657(%rip), %rax    # 0x44dee7
jmp 0x1be8ad
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be8a6
leaq 0x7df9c(%rip), %rax     # 0x23c840
jmp 0x1be8ad
leaq 0x19c5f9(%rip), %rax    # 0x35aea6
movq %rax, 0x57d8f4(%rip)    # 0x73c1a8
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_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be907
leaq 0x3a560b(%rip), %rax    # 0x563f10
jmp 0x1be936
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be91b
leaq 0x291b23(%rip), %rax    # 0x45043c
jmp 0x1be936
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be92f
leaq 0x7df13(%rip), %rax     # 0x23c840
jmp 0x1be936
leaq 0x19ec69(%rip), %rax    # 0x35d59f
movq %rax, 0x57d873(%rip)    # 0x73c1b0
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_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x5672cf
testl %eax, %eax
je 0x1be990
leaq 0x3a7ad6(%rip), %rax    # 0x566464
jmp 0x1be9bf
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1be9a4
leaq 0x294026(%rip), %rax    # 0x4529c8
jmp 0x1be9bf
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1be9b8
leaq 0x7de8a(%rip), %rax     # 0x23c840
jmp 0x1be9bf
leaq 0x1a1515(%rip), %rax    # 0x35fed4
movq %rax, 0x57d7f2(%rip)    # 0x73c1b8
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