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_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_table_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 0x1bd28d
leaq 0x2ff167(%rip), %rax    # 0x4bc3f2
jmp 0x1bd2bc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd2a1
leaq 0x201205(%rip), %rax    # 0x3be4a4
jmp 0x1bd2bc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd2b5
leaq 0x805fb(%rip), %rax     # 0x23d8ae
jmp 0x1bd2bc
leaq 0xfd1ed(%rip), %rax     # 0x2ba4a9
movq %rax, 0x57ed9d(%rip)    # 0x73c060
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_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_table_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 0x1bd316
leaq 0x302f5d(%rip), %rax    # 0x4c0271
jmp 0x1bd345
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd32a
leaq 0x204ced(%rip), %rax    # 0x3c2015
jmp 0x1bd345
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd33e
leaq 0x80572(%rip), %rax     # 0x23d8ae
jmp 0x1bd345
leaq 0x101667(%rip), %rax    # 0x2be9ac
movq %rax, 0x57ed1c(%rip)    # 0x73c068
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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_table_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 0x1bd39f
leaq 0x306ccc(%rip), %rax    # 0x4c4069
jmp 0x1bd3ce
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd3b3
leaq 0x20871b(%rip), %rax    # 0x3c5acc
jmp 0x1bd3ce
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd3c7
leaq 0x804e9(%rip), %rax     # 0x23d8ae
jmp 0x1bd3ce
leaq 0x105557(%rip), %rax    # 0x2c2925
movq %rax, 0x57ec9b(%rip)    # 0x73c070
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_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_table_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 0x1bd428
leaq 0x30afd2(%rip), %rax    # 0x4c83f8
jmp 0x1bd457
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd43c
leaq 0x20c449(%rip), %rax    # 0x3c9883
jmp 0x1bd457
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd450
leaq 0x80460(%rip), %rax     # 0x23d8ae
jmp 0x1bd457
leaq 0x109776(%rip), %rax    # 0x2c6bcd
movq %rax, 0x57ec1a(%rip)    # 0x73c078
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_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd4b1
leaq 0x3242c1(%rip), %rax    # 0x4e1770
jmp 0x1bd4e0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd4c5
leaq 0x2218f2(%rip), %rax    # 0x3dedb5
jmp 0x1bd4e0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd4d9
leaq 0x7f369(%rip), %rax     # 0x23c840
jmp 0x1bd4e0
leaq 0x121a35(%rip), %rax    # 0x2def15
movq %rax, 0x57eb99(%rip)    # 0x73c080
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_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd53a
leaq 0x3281a0(%rip), %rax    # 0x4e56d8
jmp 0x1bd569
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd54e
leaq 0x22556d(%rip), %rax    # 0x3e2ab9
jmp 0x1bd569
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd562
leaq 0x7f2e0(%rip), %rax     # 0x23c840
jmp 0x1bd569
leaq 0x125f66(%rip), %rax    # 0x2e34cf
movq %rax, 0x57eb18(%rip)    # 0x73c088
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_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd5c3
leaq 0x32c24f(%rip), %rax    # 0x4e9810
jmp 0x1bd5f2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd5d7
leaq 0x22934c(%rip), %rax    # 0x3e6921
jmp 0x1bd5f2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd5eb
leaq 0x7f257(%rip), %rax     # 0x23c840
jmp 0x1bd5f2
leaq 0x12a0a8(%rip), %rax    # 0x2e769a
movq %rax, 0x57ea97(%rip)    # 0x73c090
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_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd64c
leaq 0x33095f(%rip), %rax    # 0x4edfa9
jmp 0x1bd67b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd660
leaq 0x22d476(%rip), %rax    # 0x3eaad4
jmp 0x1bd67b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd674
leaq 0x7f1ce(%rip), %rax     # 0x23c840
jmp 0x1bd67b
leaq 0x12e5fa(%rip), %rax    # 0x2ebc75
movq %rax, 0x57ea16(%rip)    # 0x73c098
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_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd6d5
leaq 0x30f0cb(%rip), %rax    # 0x4cc79e
jmp 0x1bd704
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd6e9
leaq 0x2101f0(%rip), %rax    # 0x3cd8d7
jmp 0x1bd704
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd6fd
leaq 0x7f145(%rip), %rax     # 0x23c840
jmp 0x1bd704
leaq 0x10deae(%rip), %rax    # 0x2cb5b2
movq %rax, 0x57e995(%rip)    # 0x73c0a0
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_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd75e
leaq 0x3130f5(%rip), %rax    # 0x4d0851
jmp 0x1bd78d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd772
leaq 0x213cdd(%rip), %rax    # 0x3d144d
jmp 0x1bd78d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd786
leaq 0x7f0bc(%rip), %rax     # 0x23c840
jmp 0x1bd78d
leaq 0x1121cf(%rip), %rax    # 0x2cf95c
movq %rax, 0x57e914(%rip)    # 0x73c0a8
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_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd7e7
leaq 0x3180ff(%rip), %rax    # 0x4d58e4
jmp 0x1bd816
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd7fb
leaq 0x217d70(%rip), %rax    # 0x3d5569
jmp 0x1bd816
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd80f
leaq 0x7f033(%rip), %rax     # 0x23c840
jmp 0x1bd816
leaq 0x1166d0(%rip), %rax    # 0x2d3ee6
movq %rax, 0x57e893(%rip)    # 0x73c0b0
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_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_table_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_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_table_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 0x1bd870
leaq 0x31ecf8(%rip), %rax    # 0x4dc566
jmp 0x1bd89f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd884
leaq 0x21ce95(%rip), %rax    # 0x3da717
jmp 0x1bd89f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd898
leaq 0x7efaa(%rip), %rax     # 0x23c840
jmp 0x1bd89f
leaq 0x11c2dc(%rip), %rax    # 0x2d9b7b
movq %rax, 0x57e812(%rip)    # 0x73c0b8
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_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1bd8f9
leaq 0x3338a9(%rip), %rax    # 0x4f11a0
jmp 0x1bd928
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd90d
leaq 0x22fe52(%rip), %rax    # 0x3ed75d
jmp 0x1bd928
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd921
leaq 0x7ff8f(%rip), %rax     # 0x23d8ae
jmp 0x1bd928
leaq 0x1316dc(%rip), %rax    # 0x2ef004
movq %rax, 0x57e791(%rip)    # 0x73c0c0
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_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1bd982
leaq 0x335735(%rip), %rax    # 0x4f30b5
jmp 0x1bd9b1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bd996
leaq 0x231b16(%rip), %rax    # 0x3ef4aa
jmp 0x1bd9b1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bd9aa
leaq 0x7ff06(%rip), %rax     # 0x23d8ae
jmp 0x1bd9b1
leaq 0x13386f(%rip), %rax    # 0x2f1220
movq %rax, 0x57e710(%rip)    # 0x73c0c8
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_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1bda0b
leaq 0x3377d4(%rip), %rax    # 0x4f51dd
jmp 0x1bda3a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bda1f
leaq 0x233916(%rip), %rax    # 0x3f1333
jmp 0x1bda3a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bda33
leaq 0x7fe7d(%rip), %rax     # 0x23d8ae
jmp 0x1bda3a
leaq 0x1357e3(%rip), %rax    # 0x2f321d
movq %rax, 0x57e68f(%rip)    # 0x73c0d0
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_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1bda94
leaq 0x339da0(%rip), %rax    # 0x4f7832
jmp 0x1bdac3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdaa8
leaq 0x23595c(%rip), %rax    # 0x3f3402
jmp 0x1bdac3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdabc
leaq 0x7fdf4(%rip), %rax     # 0x23d8ae
jmp 0x1bdac3
leaq 0x137af5(%rip), %rax    # 0x2f55b8
movq %rax, 0x57e60e(%rip)    # 0x73c0d8
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_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1bdb1d
leaq 0x34bcd3(%rip), %rax    # 0x5097ee
jmp 0x1bdb4c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdb31
leaq 0x2423ea(%rip), %rax    # 0x3fff19
jmp 0x1bdb4c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdb45
leaq 0x7ecfd(%rip), %rax     # 0x23c840
jmp 0x1bdb4c
leaq 0x1462f3(%rip), %rax    # 0x303e3f
movq %rax, 0x57e58d(%rip)    # 0x73c0e0
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_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1bdba6
leaq 0x34d94d(%rip), %rax    # 0x50b4f1
jmp 0x1bdbd5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdbba
leaq 0x243f48(%rip), %rax    # 0x401b00
jmp 0x1bdbd5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdbce
leaq 0x7ec74(%rip), %rax     # 0x23c840
jmp 0x1bdbd5
leaq 0x1482ba(%rip), %rax    # 0x305e8f
movq %rax, 0x57e50c(%rip)    # 0x73c0e8
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_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1bdc2f
leaq 0x34f759(%rip), %rax    # 0x50d386
jmp 0x1bdc5e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdc43
leaq 0x245ad6(%rip), %rax    # 0x403717
jmp 0x1bdc5e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdc57
leaq 0x7ebeb(%rip), %rax     # 0x23c840
jmp 0x1bdc5e
leaq 0x149f86(%rip), %rax    # 0x307be4
movq %rax, 0x57e48b(%rip)    # 0x73c0f0
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_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1bdcb8
leaq 0x351b2c(%rip), %rax    # 0x50f7e2
jmp 0x1bdce7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdccc
leaq 0x247900(%rip), %rax    # 0x4055ca
jmp 0x1bdce7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdce0
leaq 0x7eb62(%rip), %rax     # 0x23c840
jmp 0x1bdce7
leaq 0x14c060(%rip), %rax    # 0x309d47
movq %rax, 0x57e40a(%rip)    # 0x73c0f8
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_64_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1bdd41
leaq 0x33c2f9(%rip), %rax    # 0x4fa038
jmp 0x1bdd70
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bdd55
leaq 0x237822(%rip), %rax    # 0x3f5575
jmp 0x1bdd70
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bdd69
leaq 0x7ead9(%rip), %rax     # 0x23c840
jmp 0x1bdd70
leaq 0x13a05c(%rip), %rax    # 0x2f7dcc
movq %rax, 0x57e389(%rip)    # 0x73c100
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_32_dispatcher
parasail_result_t* parasail_sg_qb_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_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_rowcol_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1bddca
leaq 0x33ea6f(%rip), %rax    # 0x4fc837
jmp 0x1bddf9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1bddde
leaq 0x239655(%rip), %rax    # 0x3f7431
jmp 0x1bddf9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1bddf2
leaq 0x7ea50(%rip), %rax     # 0x23c840
jmp 0x1bddf9
leaq 0x13c313(%rip), %rax    # 0x2fa10c
movq %rax, 0x57e308(%rip)    # 0x73c108
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