LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x594f9c
testl %eax, %eax
je 0x21a7d4
leaq 0x2db27f(%rip), %rax    # 0x4f5a51
jmp 0x21a803
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a7e8
leaq 0x1e6a41(%rip), %rax    # 0x401227
jmp 0x21a803
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a7fc
leaq 0x80120(%rip), %rax     # 0x29a91a
jmp 0x21a803
leaq 0xf90b3(%rip), %rax     # 0x3138b6
movq %rax, 0x58886e(%rip)    # 0x7a3078
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21a85d
leaq 0x2f5d86(%rip), %rax    # 0x5105e1
jmp 0x21a88c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a871
leaq 0x1fb8e4(%rip), %rax    # 0x416153
jmp 0x21a88c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a885
leaq 0x7f219(%rip), %rax     # 0x299a9c
jmp 0x21a88c
leaq 0x10fc7b(%rip), %rax    # 0x32a507
movq %rax, 0x5887ed(%rip)    # 0x7a3080
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21a8e6
leaq 0x2f9630(%rip), %rax    # 0x513f14
jmp 0x21a915
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a8fa
leaq 0x1feb87(%rip), %rax    # 0x41947f
jmp 0x21a915
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a90e
leaq 0x7f190(%rip), %rax     # 0x299a9c
jmp 0x21a915
leaq 0x1135dd(%rip), %rax    # 0x32def2
movq %rax, 0x58876c(%rip)    # 0x7a3088
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21a96f
leaq 0x2fdcde(%rip), %rax    # 0x51864b
jmp 0x21a99e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21a983
leaq 0x2024ed(%rip), %rax    # 0x41ce6e
jmp 0x21a99e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21a997
leaq 0x7f107(%rip), %rax     # 0x299a9c
jmp 0x21a99e
leaq 0x117269(%rip), %rax    # 0x331c07
movq %rax, 0x5886eb(%rip)    # 0x7a3090
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21a9f8
leaq 0x30274f(%rip), %rax    # 0x51d145
jmp 0x21aa27
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21aa0c
leaq 0x2071d8(%rip), %rax    # 0x421be2
jmp 0x21aa27
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21aa20
leaq 0x7f07e(%rip), %rax     # 0x299a9c
jmp 0x21aa27
leaq 0x11c31f(%rip), %rax    # 0x336d46
movq %rax, 0x58866a(%rip)    # 0x7a3098
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21aa81
leaq 0x2df657(%rip), %rax    # 0x4fa0d6
jmp 0x21aab0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21aa95
leaq 0x1ea54a(%rip), %rax    # 0x404fdd
jmp 0x21aab0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21aaa9
leaq 0x7eff5(%rip), %rax     # 0x299a9c
jmp 0x21aab0
leaq 0xfd2a3(%rip), %rax     # 0x317d53
movq %rax, 0x5885e9(%rip)    # 0x7a30a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21ab0a
leaq 0x2e40b6(%rip), %rax    # 0x4febbe
jmp 0x21ab39
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ab1e
leaq 0x1ee00b(%rip), %rax    # 0x408b27
jmp 0x21ab39
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ab32
leaq 0x7ef6c(%rip), %rax     # 0x299a9c
jmp 0x21ab39
leaq 0x101397(%rip), %rax    # 0x31bed0
movq %rax, 0x588568(%rip)    # 0x7a30a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21ab93
leaq 0x2e9434(%rip), %rax    # 0x503fc5
jmp 0x21abc2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21aba7
leaq 0x1f21b9(%rip), %rax    # 0x40cd5e
jmp 0x21abc2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21abbb
leaq 0x7eee3(%rip), %rax     # 0x299a9c
jmp 0x21abc2
leaq 0x105848(%rip), %rax    # 0x32040a
movq %rax, 0x5884e7(%rip)    # 0x7a30b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21ac1c
leaq 0x2f05ca(%rip), %rax    # 0x50b1e4
jmp 0x21ac4b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ac30
leaq 0x1f733d(%rip), %rax    # 0x411f6b
jmp 0x21ac4b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ac44
leaq 0x7ee5a(%rip), %rax     # 0x299a9c
jmp 0x21ac4b
leaq 0x10b08e(%rip), %rax    # 0x325cd9
movq %rax, 0x588466(%rip)    # 0x7a30b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21aca5
leaq 0x305835(%rip), %rax    # 0x5204d8
jmp 0x21acd4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21acb9
leaq 0x209fda(%rip), %rax    # 0x424c91
jmp 0x21acd4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21accd
leaq 0x7fc4f(%rip), %rax     # 0x29a91a
jmp 0x21acd4
leaq 0x11f525(%rip), %rax    # 0x33a1f9
movq %rax, 0x5883e5(%rip)    # 0x7a30c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21ad2e
leaq 0x307645(%rip), %rax    # 0x522371
jmp 0x21ad5d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ad42
leaq 0x20b980(%rip), %rax    # 0x4266c0
jmp 0x21ad5d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ad56
leaq 0x7fbc6(%rip), %rax     # 0x29a91a
jmp 0x21ad5d
leaq 0x121141(%rip), %rax    # 0x33be9e
movq %rax, 0x588364(%rip)    # 0x7a30c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21adb7
leaq 0x309292(%rip), %rax    # 0x524047
jmp 0x21ade6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21adcb
leaq 0x20d2c0(%rip), %rax    # 0x428089
jmp 0x21ade6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21addf
leaq 0x7fb3d(%rip), %rax     # 0x29a91a
jmp 0x21ade6
leaq 0x122ba1(%rip), %rax    # 0x33d987
movq %rax, 0x5882e3(%rip)    # 0x7a30d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21ae40
leaq 0x30b4c9(%rip), %rax    # 0x526307
jmp 0x21ae6f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ae54
leaq 0x20eedd(%rip), %rax    # 0x429d2f
jmp 0x21ae6f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ae68
leaq 0x7fab4(%rip), %rax     # 0x29a91a
jmp 0x21ae6f
leaq 0x124a0f(%rip), %rax    # 0x33f87e
movq %rax, 0x588262(%rip)    # 0x7a30d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21aec9
leaq 0x31d981(%rip), %rax    # 0x538848
jmp 0x21aef8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21aedd
leaq 0x21b310(%rip), %rax    # 0x4361eb
jmp 0x21aef8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21aef1
leaq 0x7ebad(%rip), %rax     # 0x299a9c
jmp 0x21aef8
leaq 0x131ca0(%rip), %rax    # 0x34cb98
movq %rax, 0x5881e1(%rip)    # 0x7a30e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21af52
leaq 0x31f3fd(%rip), %rax    # 0x53a34d
jmp 0x21af81
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21af66
leaq 0x21cb3b(%rip), %rax    # 0x437a9f
jmp 0x21af81
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21af7a
leaq 0x7eb24(%rip), %rax     # 0x299a9c
jmp 0x21af81
leaq 0x133630(%rip), %rax    # 0x34e5b1
movq %rax, 0x588160(%rip)    # 0x7a30e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21afdb
leaq 0x320e11(%rip), %rax    # 0x53bdea
jmp 0x21b00a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21afef
leaq 0x21e297(%rip), %rax    # 0x439284
jmp 0x21b00a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b003
leaq 0x7ea9b(%rip), %rax     # 0x299a9c
jmp 0x21b00a
leaq 0x134e52(%rip), %rax    # 0x34fe5c
movq %rax, 0x5880df(%rip)    # 0x7a30f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21b064
leaq 0x322e68(%rip), %rax    # 0x53deca
jmp 0x21b093
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b078
leaq 0x21fced(%rip), %rax    # 0x43ad63
jmp 0x21b093
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b08c
leaq 0x7ea12(%rip), %rax     # 0x299a9c
jmp 0x21b093
leaq 0x136ae1(%rip), %rax    # 0x351b74
movq %rax, 0x58805e(%rip)    # 0x7a30f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21b0ed
leaq 0x30db02(%rip), %rax    # 0x528bed
jmp 0x21b11c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b101
leaq 0x210be4(%rip), %rax    # 0x42bce3
jmp 0x21b11c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b115
leaq 0x7e989(%rip), %rax     # 0x299a9c
jmp 0x21b11c
leaq 0x126a3a(%rip), %rax    # 0x341b56
movq %rax, 0x587fdd(%rip)    # 0x7a3100
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21b176
leaq 0x3102fc(%rip), %rax    # 0x52b470
jmp 0x21b1a5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b18a
leaq 0x21292c(%rip), %rax    # 0x42dab4
jmp 0x21b1a5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b19e
leaq 0x7e900(%rip), %rax     # 0x299a9c
jmp 0x21b1a5
leaq 0x128b34(%rip), %rax    # 0x343cd9
movq %rax, 0x587f5c(%rip)    # 0x7a3108
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21b1ff
leaq 0x313ad8(%rip), %rax    # 0x52ecd5
jmp 0x21b22e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b213
leaq 0x214e03(%rip), %rax    # 0x430014
jmp 0x21b22e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b227
leaq 0x7e877(%rip), %rax     # 0x299a9c
jmp 0x21b22e
leaq 0x12b234(%rip), %rax    # 0x346462
movq %rax, 0x587edb(%rip)    # 0x7a3110
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21b288
leaq 0x31988f(%rip), %rax    # 0x534b15
jmp 0x21b2b7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b29c
leaq 0x21865e(%rip), %rax    # 0x4338f8
jmp 0x21b2b7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b2b0
leaq 0x7e7ee(%rip), %rax     # 0x299a9c
jmp 0x21b2b7
leaq 0x12ed5e(%rip), %rax    # 0x34a015
movq %rax, 0x587e5a(%rip)    # 0x7a3118
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_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 0x594f9c
testl %eax, %eax
je 0x21b311
leaq 0x326804(%rip), %rax    # 0x541b13
jmp 0x21b340
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b325
leaq 0x223341(%rip), %rax    # 0x43e664
jmp 0x21b340
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b339
leaq 0x7f5e3(%rip), %rax     # 0x29a91a
jmp 0x21b340
leaq 0x139e52(%rip), %rax    # 0x355192
movq %rax, 0x587dd9(%rip)    # 0x7a3120
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