LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_16_dispatcher
parasail_result_t* parasail_sg_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_striped_16_pointer = parasail_sg_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x20fd0b
leaq 0x28a57e(%rip), %rax    # 0x49a287
jmp 0x20fd3a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fd1f
leaq 0x1a37d5(%rip), %rax    # 0x3b34f2
jmp 0x20fd3a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fd33
leaq 0x89ea3(%rip), %rax     # 0x299bd4
jmp 0x20fd3a
leaq 0xae090(%rip), %rax     # 0x2bddca
movq %rax, 0x59296f(%rip)    # 0x7a26b0
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_dispatch.c
// Function: parasail_sg_striped_8_dispatcher
parasail_result_t* parasail_sg_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_striped_8_pointer = parasail_sg_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x20fd94
leaq 0x28b9cd(%rip), %rax    # 0x49b75f
jmp 0x20fdc3
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fda8
leaq 0x1a4c21(%rip), %rax    # 0x3b49c7
jmp 0x20fdc3
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fdbc
leaq 0x89e1a(%rip), %rax     # 0x299bd4
jmp 0x20fdc3
leaq 0xaf73b(%rip), %rax     # 0x2bf4fe
movq %rax, 0x5928ee(%rip)    # 0x7a26b8
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_dispatch.c
// Function: parasail_sg_diag_64_dispatcher
parasail_result_t* parasail_sg_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_diag_64_pointer = parasail_sg_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x20fe1d
leaq 0x27d1bc(%rip), %rax    # 0x48cfd7
jmp 0x20fe4c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20fe31
leaq 0x199103(%rip), %rax    # 0x3a8f32
jmp 0x20fe4c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fe45
leaq 0x89d91(%rip), %rax     # 0x299bd4
jmp 0x20fe4c
leaq 0xa2c94(%rip), %rax     # 0x2b2ae0
movq %rax, 0x59286d(%rip)    # 0x7a26c0
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_dispatch.c
// Function: parasail_sg_diag_32_dispatcher
parasail_result_t* parasail_sg_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_diag_32_pointer = parasail_sg_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x20fea6
leaq 0x27f13a(%rip), %rax    # 0x48efde
jmp 0x20fed5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20feba
leaq 0x19aa7e(%rip), %rax    # 0x3aa936
jmp 0x20fed5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20fece
leaq 0x89d08(%rip), %rax     # 0x299bd4
jmp 0x20fed5
leaq 0xa492a(%rip), %rax     # 0x2b47ff
movq %rax, 0x5927ec(%rip)    # 0x7a26c8
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_dispatch.c
// Function: parasail_sg_diag_16_dispatcher
parasail_result_t* parasail_sg_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_diag_16_pointer = parasail_sg_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x20ff2f
leaq 0x28157b(%rip), %rax    # 0x4914a8
jmp 0x20ff5e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ff43
leaq 0x19c63d(%rip), %rax    # 0x3ac57e
jmp 0x20ff5e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20ff57
leaq 0x89c7f(%rip), %rax     # 0x299bd4
jmp 0x20ff5e
leaq 0xa6700(%rip), %rax     # 0x2b665e
movq %rax, 0x59276b(%rip)    # 0x7a26d0
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_dispatch.c
// Function: parasail_sg_diag_8_dispatcher
parasail_result_t* parasail_sg_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_diag_8_pointer = parasail_sg_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x20ffb8
leaq 0x284ba8(%rip), %rax    # 0x494b5e
jmp 0x20ffe7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x20ffcc
leaq 0x19ea5e(%rip), %rax    # 0x3aea28
jmp 0x20ffe7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x20ffe0
leaq 0x89bf6(%rip), %rax     # 0x299bd4
jmp 0x20ffe7
leaq 0xa8ef9(%rip), %rax     # 0x2b8ee0
movq %rax, 0x5926ea(%rip)    # 0x7a26d8
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_dispatch.c
// Function: parasail_sg_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_scan_64_pointer = parasail_sg_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x210041
leaq 0x28e95c(%rip), %rax    # 0x49e99b
jmp 0x210070
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x210055
leaq 0x1a7af3(%rip), %rax    # 0x3b7b46
jmp 0x210070
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x210069
leaq 0x8a9eb(%rip), %rax     # 0x29aa52
jmp 0x210070
leaq 0xb2438(%rip), %rax     # 0x2c24a8
movq %rax, 0x592669(%rip)    # 0x7a26e0
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_dispatch.c
// Function: parasail_sg_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_scan_32_pointer = parasail_sg_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x2100ca
leaq 0x291d36(%rip), %rax    # 0x4a1dfe
jmp 0x2100f9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2100de
leaq 0x1aab1e(%rip), %rax    # 0x3babfa
jmp 0x2100f9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2100f2
leaq 0x8a962(%rip), %rax     # 0x29aa52
jmp 0x2100f9
leaq 0xb5a8c(%rip), %rax     # 0x2c5b85
movq %rax, 0x5925e8(%rip)    # 0x7a26e8
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_dispatch.c
// Function: parasail_sg_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_scan_16_pointer = parasail_sg_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x210153
leaq 0x294b49(%rip), %rax    # 0x4a4c9a
jmp 0x210182
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x210167
leaq 0x1ad8d0(%rip), %rax    # 0x3bda35
jmp 0x210182
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21017b
leaq 0x8a8d9(%rip), %rax     # 0x29aa52
jmp 0x210182
leaq 0xb8cd8(%rip), %rax     # 0x2c8e5a
movq %rax, 0x592567(%rip)    # 0x7a26f0
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_dispatch.c
// Function: parasail_sg_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_scan_8_pointer = parasail_sg_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_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 0x2101dc
leaq 0x297982(%rip), %rax    # 0x4a7b5c
jmp 0x21020b
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2101f0
leaq 0x1b0725(%rip), %rax    # 0x3c0913
jmp 0x21020b
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x210204
leaq 0x8a850(%rip), %rax     # 0x29aa52
jmp 0x21020b
leaq 0xbc0e8(%rip), %rax     # 0x2cc2f3
movq %rax, 0x5924e6(%rip)    # 0x7a26f8
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_dispatch.c
// Function: parasail_sg_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_striped_64_pointer = parasail_sg_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x210265
leaq 0x2ac384(%rip), %rax    # 0x4bc5e7
jmp 0x210294
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x210279
leaq 0x1c1e0c(%rip), %rax    # 0x3d2083
jmp 0x210294
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21028d
leaq 0x89949(%rip), %rax     # 0x299bd4
jmp 0x210294
leaq 0xcf8ce(%rip), %rax     # 0x2dfb62
movq %rax, 0x592465(%rip)    # 0x7a2700
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_dispatch.c
// Function: parasail_sg_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_striped_32_pointer = parasail_sg_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x2102ee
leaq 0x2af309(%rip), %rax    # 0x4bf5f5
jmp 0x21031d
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x210302
leaq 0x1c4b91(%rip), %rax    # 0x3d4e91
jmp 0x21031d
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x210316
leaq 0x898c0(%rip), %rax     # 0x299bd4
jmp 0x21031d
leaq 0xd2cb5(%rip), %rax     # 0x2e2fd2
movq %rax, 0x5923e4(%rip)    # 0x7a2708
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_dispatch.c
// Function: parasail_sg_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_striped_16_pointer = parasail_sg_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x210377
leaq 0x2b1e30(%rip), %rax    # 0x4c21a5
jmp 0x2103a6
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21038b
leaq 0x1c7724(%rip), %rax    # 0x3d7aad
jmp 0x2103a6
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21039f
leaq 0x89837(%rip), %rax     # 0x299bd4
jmp 0x2103a6
leaq 0xd5bfc(%rip), %rax     # 0x2e5fa2
movq %rax, 0x592363(%rip)    # 0x7a2710
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_dispatch.c
// Function: parasail_sg_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_striped_8_pointer = parasail_sg_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x210400
leaq 0x2b49f0(%rip), %rax    # 0x4c4dee
jmp 0x21042f
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x210414
leaq 0x1ca35b(%rip), %rax    # 0x3da76d
jmp 0x21042f
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x210428
leaq 0x897ae(%rip), %rax     # 0x299bd4
jmp 0x21042f
leaq 0xd8d90(%rip), %rax     # 0x2e91bf
movq %rax, 0x5922e2(%rip)    # 0x7a2718
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_dispatch.c
// Function: parasail_sg_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_diag_64_pointer = parasail_sg_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x210489
leaq 0x29b0da(%rip), %rax    # 0x4ab561
jmp 0x2104b8
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21049d
leaq 0x1b38ce(%rip), %rax    # 0x3c3d69
jmp 0x2104b8
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2104b1
leaq 0x89725(%rip), %rax     # 0x299bd4
jmp 0x2104b8
leaq 0xbfa2b(%rip), %rax     # 0x2cfee3
movq %rax, 0x592261(%rip)    # 0x7a2720
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_dispatch.c
// Function: parasail_sg_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_diag_32_pointer = parasail_sg_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x210512
leaq 0x29ea65(%rip), %rax    # 0x4aef75
jmp 0x210541
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x210526
leaq 0x1b6b1a(%rip), %rax    # 0x3c703e
jmp 0x210541
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21053a
leaq 0x8969c(%rip), %rax     # 0x299bd4
jmp 0x210541
leaq 0xc3373(%rip), %rax     # 0x2d38b4
movq %rax, 0x5921e0(%rip)    # 0x7a2728
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_dispatch.c
// Function: parasail_sg_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_diag_16_pointer = parasail_sg_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x21059b
leaq 0x2a2915(%rip), %rax    # 0x4b2eae
jmp 0x2105ca
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2105af
leaq 0x1ba1ce(%rip), %rax    # 0x3ca77b
jmp 0x2105ca
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2105c3
leaq 0x89613(%rip), %rax     # 0x299bd4
jmp 0x2105ca
leaq 0xc6dce(%rip), %rax     # 0x2d7398
movq %rax, 0x59215f(%rip)    # 0x7a2730
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_dispatch.c
// Function: parasail_sg_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_stats_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_stats_diag_8_pointer = parasail_sg_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_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 0x210624
leaq 0x2a7c18(%rip), %rax    # 0x4b823a
jmp 0x210653
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x210638
leaq 0x1be25e(%rip), %rax    # 0x3ce894
jmp 0x210653
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21064c
leaq 0x8958a(%rip), %rax     # 0x299bd4
jmp 0x210653
leaq 0xcb5a9(%rip), %rax     # 0x2dbbfc
movq %rax, 0x5920de(%rip)    # 0x7a2738
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_dispatch.c
// Function: parasail_sg_table_scan_64_dispatcher
parasail_result_t* parasail_sg_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2106ad
leaq 0x2b83b0(%rip), %rax    # 0x4c8a5b
jmp 0x2106dc
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2106c1
leaq 0x1cc477(%rip), %rax    # 0x3dcb36
jmp 0x2106dc
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2106d5
leaq 0x8a37f(%rip), %rax     # 0x29aa52
jmp 0x2106dc
leaq 0xdc0c4(%rip), %rax     # 0x2ec7a0
movq %rax, 0x59205d(%rip)    # 0x7a2740
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_dispatch.c
// Function: parasail_sg_table_scan_32_dispatcher
parasail_result_t* parasail_sg_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x210736
leaq 0x2ba2c1(%rip), %rax    # 0x4ca9f5
jmp 0x210765
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21074a
leaq 0x1cdd73(%rip), %rax    # 0x3de4bb
jmp 0x210765
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x21075e
leaq 0x8a2f6(%rip), %rax     # 0x29aa52
jmp 0x210765
leaq 0xddc21(%rip), %rax     # 0x2ee386
movq %rax, 0x591fdc(%rip)    # 0x7a2748
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_dispatch.c
// Function: parasail_sg_table_scan_16_dispatcher
parasail_result_t* parasail_sg_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x594f9c
testl %eax, %eax
je 0x2107bf
leaq 0x2bc0d5(%rip), %rax    # 0x4cc892
jmp 0x2107ee
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2107d3
leaq 0x1cf7a9(%rip), %rax    # 0x3dff7a
jmp 0x2107ee
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2107e7
leaq 0x8a26d(%rip), %rax     # 0x29aa52
jmp 0x2107ee
leaq 0xdf766(%rip), %rax     # 0x2eff54
movq %rax, 0x591f5b(%rip)    # 0x7a2750
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_dispatch.c
// Function: parasail_sg_table_scan_8_dispatcher
parasail_result_t* parasail_sg_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_table_scan_8_pointer = parasail_sg_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_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 0x210848
leaq 0x2be3f4(%rip), %rax    # 0x4cec3a
jmp 0x210877
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x21085c
leaq 0x1d15e2(%rip), %rax    # 0x3e1e3c
jmp 0x210877
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x210870
leaq 0x8a1e4(%rip), %rax     # 0x29aa52
jmp 0x210877
leaq 0xe18a7(%rip), %rax     # 0x2f211e
movq %rax, 0x591eda(%rip)    # 0x7a2758
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_dispatch.c
// Function: parasail_sg_table_striped_64_dispatcher
parasail_result_t* parasail_sg_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_table_striped_64_pointer = parasail_sg_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x2108d1
leaq 0x2cf744(%rip), %rax    # 0x4e0013
jmp 0x210900
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2108e5
leaq 0x1dd292(%rip), %rax    # 0x3edb75
jmp 0x210900
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2108f9
leaq 0x892dd(%rip), %rax     # 0x299bd4
jmp 0x210900
leaq 0xee5d9(%rip), %rax     # 0x2feed9
movq %rax, 0x591e59(%rip)    # 0x7a2760
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