LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5c8fdb
testl %eax, %eax
je 0x21196f
leaq 0x2da7d2(%rip), %rax    # 0x4ec13f
jmp 0x21199e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211983
leaq 0x1e7aba(%rip), %rax    # 0x3f943b
jmp 0x21199e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211997
leaq 0x8980d(%rip), %rax     # 0x29b1a2
jmp 0x21199e
leaq 0xdf231(%rip), %rax     # 0x2f0bcf
movq %rax, 0x5c6d6b(%rip)    # 0x7d8710
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x2119f8
leaq 0x2dee60(%rip), %rax    # 0x4f0856
jmp 0x211a27
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211a0c
leaq 0x1eb02f(%rip), %rax    # 0x3fca39
jmp 0x211a27
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211a20
leaq 0x89784(%rip), %rax     # 0x29b1a2
jmp 0x211a27
leaq 0xe32ce(%rip), %rax     # 0x2f4cf5
movq %rax, 0x5c6cea(%rip)    # 0x7d8718
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211a81
leaq 0x2c451d(%rip), %rax    # 0x4d5f9c
jmp 0x211ab0
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211a95
leaq 0x1d3b48(%rip), %rax    # 0x3e55db
jmp 0x211ab0
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211aa9
leaq 0x896fb(%rip), %rax     # 0x29b1a2
jmp 0x211ab0
leaq 0xc7b39(%rip), %rax     # 0x2d95e9
movq %rax, 0x5c6c69(%rip)    # 0x7d8720
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211b0a
leaq 0x2c7a95(%rip), %rax    # 0x4d959d
jmp 0x211b39
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211b1e
leaq 0x1d6c24(%rip), %rax    # 0x3e8740
jmp 0x211b39
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211b32
leaq 0x89672(%rip), %rax     # 0x29b1a2
jmp 0x211b39
leaq 0xcb540(%rip), %rax     # 0x2dd079
movq %rax, 0x5c6be8(%rip)    # 0x7d8728
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211b93
leaq 0x2cb9e0(%rip), %rax    # 0x4dd571
jmp 0x211bc2
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211ba7
leaq 0x1da2a6(%rip), %rax    # 0x3ebe4b
jmp 0x211bc2
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211bbb
leaq 0x895e9(%rip), %rax     # 0x29b1a2
jmp 0x211bc2
leaq 0xceed5(%rip), %rax     # 0x2e0a97
movq %rax, 0x5c6b67(%rip)    # 0x7d8730
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211c1c
leaq 0x2d076b(%rip), %rax    # 0x4e2385
jmp 0x211c4b
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211c30
leaq 0x1de2b9(%rip), %rax    # 0x3efee7
jmp 0x211c4b
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211c44
leaq 0x89560(%rip), %rax     # 0x29b1a2
jmp 0x211c4b
leaq 0xd3a7a(%rip), %rax     # 0x2e56c5
movq %rax, 0x5c6ae6(%rip)    # 0x7d8738
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211ca5
leaq 0x2e2035(%rip), %rax    # 0x4f3cd8
jmp 0x211cd4
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211cb9
leaq 0x1ecfed(%rip), %rax    # 0x3feca4
jmp 0x211cd4
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211ccd
leaq 0x8a7d3(%rip), %rax     # 0x29c49e
jmp 0x211cd4
leaq 0xe6b5a(%rip), %rax     # 0x2f882e
movq %rax, 0x5c6a65(%rip)    # 0x7d8740
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211d2e
leaq 0x2e3c6f(%rip), %rax    # 0x4f599b
jmp 0x211d5d
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211d42
leaq 0x1eeafb(%rip), %rax    # 0x40083b
jmp 0x211d5d
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211d56
leaq 0x8a74a(%rip), %rax     # 0x29c49e
jmp 0x211d5d
leaq 0xe8b2d(%rip), %rax     # 0x2fa88a
movq %rax, 0x5c69e4(%rip)    # 0x7d8748
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211db7
leaq 0x2e67c5(%rip), %rax    # 0x4f857a
jmp 0x211de6
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211dcb
leaq 0x1f0ab5(%rip), %rax    # 0x40287e
jmp 0x211de6
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211ddf
leaq 0x8a6c1(%rip), %rax     # 0x29c49e
jmp 0x211de6
leaq 0xeaf36(%rip), %rax     # 0x2fcd1c
movq %rax, 0x5c6963(%rip)    # 0x7d8750
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211e40
leaq 0x2ea5d8(%rip), %rax    # 0x4fc416
jmp 0x211e6f
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211e54
leaq 0x1f3225(%rip), %rax    # 0x405077
jmp 0x211e6f
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211e68
leaq 0x8a638(%rip), %rax     # 0x29c49e
jmp 0x211e6f
leaq 0xedff8(%rip), %rax     # 0x2ffe67
movq %rax, 0x5c68e2(%rip)    # 0x7d8758
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_O3/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 0x5c8fdb
testl %eax, %eax
je 0x211ec9
leaq 0x2f9ee3(%rip), %rax    # 0x50bdaa
jmp 0x211ef8
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211edd
leaq 0x1fe750(%rip), %rax    # 0x41062b
jmp 0x211ef8
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211ef1
leaq 0x892b3(%rip), %rax     # 0x29b1a2
jmp 0x211ef8
leaq 0xfb17d(%rip), %rax     # 0x30d075
movq %rax, 0x5c6861(%rip)    # 0x7d8760
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_striped_32_dispatcher
parasail_result_t* parasail_sg_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x211f52
leaq 0x2fb8fa(%rip), %rax    # 0x50d84a
jmp 0x211f81
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211f66
leaq 0x1fffbb(%rip), %rax    # 0x411f1f
jmp 0x211f81
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x211f7a
leaq 0x8922a(%rip), %rax     # 0x29b1a2
jmp 0x211f81
leaq 0xfcece(%rip), %rax     # 0x30ee4f
movq %rax, 0x5c67e0(%rip)    # 0x7d8768
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_striped_16_dispatcher
parasail_result_t* parasail_sg_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x211fdb
leaq 0x2fe4a6(%rip), %rax    # 0x51047f
jmp 0x21200a
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x211fef
leaq 0x201e8f(%rip), %rax    # 0x413e7c
jmp 0x21200a
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212003
leaq 0x891a1(%rip), %rax     # 0x29b1a2
jmp 0x21200a
leaq 0xff19a(%rip), %rax     # 0x3111a4
movq %rax, 0x5c675f(%rip)    # 0x7d8770
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_striped_8_dispatcher
parasail_result_t* parasail_sg_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212064
leaq 0x302518(%rip), %rax    # 0x51457a
jmp 0x212093
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212078
leaq 0x20477c(%rip), %rax    # 0x4167f2
jmp 0x212093
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21208c
leaq 0x89118(%rip), %rax     # 0x29b1a2
jmp 0x212093
leaq 0x102365(%rip), %rax    # 0x3143f8
movq %rax, 0x5c66de(%rip)    # 0x7d8778
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_diag_64_dispatcher
parasail_result_t* parasail_sg_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2120ed
leaq 0x2ec621(%rip), %rax    # 0x4fe70c
jmp 0x21211c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212101
leaq 0x1f4d33(%rip), %rax    # 0x406e32
jmp 0x21211c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212115
leaq 0x8908f(%rip), %rax     # 0x29b1a2
jmp 0x21211c
leaq 0xf0217(%rip), %rax     # 0x302333
movq %rax, 0x5c665d(%rip)    # 0x7d8780
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_diag_32_dispatcher
parasail_result_t* parasail_sg_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212176
leaq 0x2ee934(%rip), %rax    # 0x500aa8
jmp 0x2121a5
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21218a
leaq 0x1f6892(%rip), %rax    # 0x408a1a
jmp 0x2121a5
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21219e
leaq 0x89006(%rip), %rax     # 0x29b1a2
jmp 0x2121a5
leaq 0xf2287(%rip), %rax     # 0x30442c
movq %rax, 0x5c65dc(%rip)    # 0x7d8788
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_diag_16_dispatcher
parasail_result_t* parasail_sg_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2121ff
leaq 0x2f1d30(%rip), %rax    # 0x503f2d
jmp 0x21222e
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212213
leaq 0x1f8b25(%rip), %rax    # 0x40ad36
jmp 0x21222e
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212227
leaq 0x88f7d(%rip), %rax     # 0x29b1a2
jmp 0x21222e
leaq 0xf477a(%rip), %rax     # 0x3069a8
movq %rax, 0x5c655b(%rip)    # 0x7d8790
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_diag_8_dispatcher
parasail_result_t* parasail_sg_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212288
leaq 0x2f6d4d(%rip), %rax    # 0x508fd3
jmp 0x2122b7
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x21229c
leaq 0x1fbe8b(%rip), %rax    # 0x40e125
jmp 0x2122b7
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2122b0
leaq 0x88ef4(%rip), %rax     # 0x29b1a2
jmp 0x2122b7
leaq 0xf80f5(%rip), %rax     # 0x30a3ac
movq %rax, 0x5c64da(%rip)    # 0x7d8798
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212311
leaq 0x30552f(%rip), %rax    # 0x51783e
jmp 0x212340
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212325
leaq 0x207c73(%rip), %rax    # 0x419f96
jmp 0x212340
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x212339
leaq 0x8a167(%rip), %rax     # 0x29c49e
jmp 0x212340
leaq 0x105c52(%rip), %rax    # 0x317f92
movq %rax, 0x5c6459(%rip)    # 0x7d87a0
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x21239a
leaq 0x308b80(%rip), %rax    # 0x51af18
jmp 0x2123c9
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2123ae
leaq 0x20b0e2(%rip), %rax    # 0x41d48e
jmp 0x2123c9
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2123c2
leaq 0x8a0de(%rip), %rax     # 0x29c49e
jmp 0x2123c9
leaq 0x1099a2(%rip), %rax    # 0x31bd6b
movq %rax, 0x5c63d8(%rip)    # 0x7d87a8
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x212423
leaq 0x30d260(%rip), %rax    # 0x51f681
jmp 0x212452
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x212437
leaq 0x20ed09(%rip), %rax    # 0x42113e
jmp 0x212452
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x21244b
leaq 0x8a055(%rip), %rax     # 0x29c49e
jmp 0x212452
leaq 0x10de2b(%rip), %rax    # 0x32027d
movq %rax, 0x5c6357(%rip)    # 0x7d87b0
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_O3/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x2124ac
leaq 0x3129f0(%rip), %rax    # 0x524e9a
jmp 0x2124db
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x2124c0
leaq 0x2136dd(%rip), %rax    # 0x425b9b
jmp 0x2124db
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x2124d4
leaq 0x89fcc(%rip), %rax     # 0x29c49e
jmp 0x2124db
leaq 0x1134ea(%rip), %rax    # 0x3259c5
movq %rax, 0x5c62d6(%rip)    # 0x7d87b8
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