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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b39a
leaq 0x32a412(%rip), %rax    # 0x5457aa
jmp 0x21b3c9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b3ae
leaq 0x22692a(%rip), %rax    # 0x441cd6
jmp 0x21b3c9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b3c2
leaq 0x7f55a(%rip), %rax     # 0x29a91a
jmp 0x21b3c9
leaq 0x13dade(%rip), %rax    # 0x358ea7
movq %rax, 0x587d58(%rip)    # 0x7a3128
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_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b423
leaq 0x32e433(%rip), %rax    # 0x549854
jmp 0x21b452
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b437
leaq 0x22a0ac(%rip), %rax    # 0x4454e1
jmp 0x21b452
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b44b
leaq 0x7f4d1(%rip), %rax     # 0x29a91a
jmp 0x21b452
leaq 0x1416da(%rip), %rax    # 0x35cb2c
movq %rax, 0x587cd7(%rip)    # 0x7a3130
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_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b4ac
leaq 0x3324a5(%rip), %rax    # 0x54d94f
jmp 0x21b4db
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b4c0
leaq 0x22e0fa(%rip), %rax    # 0x4495b8
jmp 0x21b4db
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b4d4
leaq 0x7f448(%rip), %rax     # 0x29a91a
jmp 0x21b4db
leaq 0x145cdb(%rip), %rax    # 0x3611b6
movq %rax, 0x587c56(%rip)    # 0x7a3138
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_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b535
leaq 0x34cd6b(%rip), %rax    # 0x56829e
jmp 0x21b564
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b549
leaq 0x243868(%rip), %rax    # 0x45edaf
jmp 0x21b564
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b55d
leaq 0x7e541(%rip), %rax     # 0x299a9c
jmp 0x21b564
leaq 0x15cfac(%rip), %rax    # 0x378510
movq %rax, 0x587bd5(%rip)    # 0x7a3140
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_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b5be
leaq 0x3504dd(%rip), %rax    # 0x56ba99
jmp 0x21b5ed
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b5d2
leaq 0x246ad3(%rip), %rax    # 0x4620a3
jmp 0x21b5ed
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b5e6
leaq 0x7e4b8(%rip), %rax     # 0x299a9c
jmp 0x21b5ed
leaq 0x1608ea(%rip), %rax    # 0x37bed7
movq %rax, 0x587b54(%rip)    # 0x7a3148
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_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b647
leaq 0x354003(%rip), %rax    # 0x56f648
jmp 0x21b676
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b65b
leaq 0x249eb7(%rip), %rax    # 0x465510
jmp 0x21b676
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b66f
leaq 0x7e42f(%rip), %rax     # 0x299a9c
jmp 0x21b676
leaq 0x164124(%rip), %rax    # 0x37f79a
movq %rax, 0x587ad3(%rip)    # 0x7a3150
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_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b6d0
leaq 0x357e13(%rip), %rax    # 0x5734e1
jmp 0x21b6ff
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b6e4
leaq 0x24dcd9(%rip), %rax    # 0x4693bb
jmp 0x21b6ff
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b6f8
leaq 0x7e3a6(%rip), %rax     # 0x299a9c
jmp 0x21b6ff
leaq 0x1683a6(%rip), %rax    # 0x383aa5
movq %rax, 0x587a52(%rip)    # 0x7a3158
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_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b759
leaq 0x3369d3(%rip), %rax    # 0x55212a
jmp 0x21b788
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b76d
leaq 0x231dc8(%rip), %rax    # 0x44d533
jmp 0x21b788
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b781
leaq 0x7e31d(%rip), %rax     # 0x299a9c
jmp 0x21b788
leaq 0x14a06d(%rip), %rax    # 0x3657f5
movq %rax, 0x5879d1(%rip)    # 0x7a3160
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_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b7e2
leaq 0x33af7e(%rip), %rax    # 0x55675e
jmp 0x21b811
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b7f6
leaq 0x235bbf(%rip), %rax    # 0x4513b3
jmp 0x21b811
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b80a
leaq 0x7e294(%rip), %rax     # 0x299a9c
jmp 0x21b811
leaq 0x14e364(%rip), %rax    # 0x369b75
movq %rax, 0x587950(%rip)    # 0x7a3168
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_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b86b
leaq 0x340108(%rip), %rax    # 0x55b971
jmp 0x21b89a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b87f
leaq 0x239f7d(%rip), %rax    # 0x4557fa
jmp 0x21b89a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b893
leaq 0x7e20b(%rip), %rax     # 0x299a9c
jmp 0x21b89a
leaq 0x15296a(%rip), %rax    # 0x36e204
movq %rax, 0x5878cf(%rip)    # 0x7a3170
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_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_rowcol_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b8f4
leaq 0x34758c(%rip), %rax    # 0x562e7e
jmp 0x21b923
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b908
leaq 0x23f2a0(%rip), %rax    # 0x45aba6
jmp 0x21b923
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b91c
leaq 0x7e182(%rip), %rax     # 0x299a9c
jmp 0x21b923
leaq 0x158319(%rip), %rax    # 0x373c3c
movq %rax, 0x58784e(%rip)    # 0x7a3178
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_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_trace_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21b97d
leaq 0x35ae1b(%rip), %rax    # 0x576796
jmp 0x21b9ac
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21b991
leaq 0x2506bb(%rip), %rax    # 0x46c04a
jmp 0x21b9ac
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21b9a5
leaq 0x7ef77(%rip), %rax     # 0x29a91a
jmp 0x21b9ac
leaq 0x16b101(%rip), %rax    # 0x386aad
movq %rax, 0x5877cd(%rip)    # 0x7a3180
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_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_trace_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21ba06
leaq 0x35cd19(%rip), %rax    # 0x57871d
jmp 0x21ba35
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21ba1a
leaq 0x2521fe(%rip), %rax    # 0x46dc16
jmp 0x21ba35
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21ba2e
leaq 0x7eeee(%rip), %rax     # 0x29a91a
jmp 0x21ba35
leaq 0x16cf22(%rip), %rax    # 0x388957
movq %rax, 0x58774c(%rip)    # 0x7a3188
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_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_trace_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21ba8f
leaq 0x35e74f(%rip), %rax    # 0x57a1dc
jmp 0x21babe
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21baa3
leaq 0x253b9e(%rip), %rax    # 0x46f63f
jmp 0x21babe
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21bab7
leaq 0x7ee65(%rip), %rax     # 0x29a91a
jmp 0x21babe
leaq 0x16ea4a(%rip), %rax    # 0x38a508
movq %rax, 0x5876cb(%rip)    # 0x7a3190
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_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_trace_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_trace_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21bb18
leaq 0x360167(%rip), %rax    # 0x57bc7d
jmp 0x21bb47
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21bb2c
leaq 0x255567(%rip), %rax    # 0x471091
jmp 0x21bb47
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21bb40
leaq 0x7eddc(%rip), %rax     # 0x29a91a
jmp 0x21bb47
leaq 0x1706d1(%rip), %rax    # 0x38c218
movq %rax, 0x58764a(%rip)    # 0x7a3198
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_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_trace_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21bba1
leaq 0x371e3e(%rip), %rax    # 0x58d9dd
jmp 0x21bbd0
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21bbb5
leaq 0x261f2a(%rip), %rax    # 0x47dadd
jmp 0x21bbd0
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21bbc9
leaq 0x7ded5(%rip), %rax     # 0x299a9c
jmp 0x21bbd0
leaq 0x17e546(%rip), %rax    # 0x39a116
movq %rax, 0x5875c9(%rip)    # 0x7a31a0
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_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_trace_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21bc2a
leaq 0x374389(%rip), %rax    # 0x58ffb1
jmp 0x21bc59
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21bc3e
leaq 0x26425e(%rip), %rax    # 0x47fe9a
jmp 0x21bc59
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21bc52
leaq 0x7de4c(%rip), %rax     # 0x299a9c
jmp 0x21bc59
leaq 0x180c26(%rip), %rax    # 0x39c87f
movq %rax, 0x587548(%rip)    # 0x7a31a8
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_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_trace_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21bcb3
leaq 0x37646a(%rip), %rax    # 0x59211b
jmp 0x21bce2
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21bcc7
leaq 0x2662dc(%rip), %rax    # 0x481fa1
jmp 0x21bce2
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21bcdb
leaq 0x7ddc3(%rip), %rax     # 0x299a9c
jmp 0x21bce2
leaq 0x182dec(%rip), %rax    # 0x39eace
movq %rax, 0x5874c7(%rip)    # 0x7a31b0
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_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_trace_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_trace_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_trace_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21bd3c
leaq 0x378579(%rip), %rax    # 0x5942b3
jmp 0x21bd6b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21bd50
leaq 0x26836d(%rip), %rax    # 0x4840bb
jmp 0x21bd6b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21bd64
leaq 0x7dd3a(%rip), %rax     # 0x299a9c
jmp 0x21bd6b
leaq 0x1851ad(%rip), %rax    # 0x3a0f18
movq %rax, 0x587446(%rip)    # 0x7a31b8
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_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_trace_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_trace_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_trace_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21bdc5
leaq 0x36253f(%rip), %rax    # 0x57e302
jmp 0x21bdf4
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21bdd9
leaq 0x25724c(%rip), %rax    # 0x473023
jmp 0x21bdf4
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21bded
leaq 0x7dcb1(%rip), %rax     # 0x299a9c
jmp 0x21bdf4
leaq 0x1728b9(%rip), %rax    # 0x38e6ad
movq %rax, 0x5873c5(%rip)    # 0x7a31c0
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_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_trace_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_trace_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_trace_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21be4e
leaq 0x364eb3(%rip), %rax    # 0x580cff
jmp 0x21be7d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21be62
leaq 0x2591a7(%rip), %rax    # 0x475007
jmp 0x21be7d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21be76
leaq 0x7dc28(%rip), %rax     # 0x299a9c
jmp 0x21be7d
leaq 0x174bb3(%rip), %rax    # 0x390a30
movq %rax, 0x587344(%rip)    # 0x7a31c8
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_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_trace_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_trace_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_trace_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x21bed7
leaq 0x36841a(%rip), %rax    # 0x5842ef
jmp 0x21bf06
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21beeb
leaq 0x25b65f(%rip), %rax    # 0x477548
jmp 0x21bf06
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21beff
leaq 0x7db9f(%rip), %rax     # 0x299a9c
jmp 0x21bf06
leaq 0x1772b8(%rip), %rax    # 0x3931be
movq %rax, 0x5872c3(%rip)    # 0x7a31d0
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