LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_64_pointer = parasail_sw_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_64_pointer = parasail_sw_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_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 0x5672cf
testl %eax, %eax
je 0x1b7d6d
leaq 0x2c3c91(%rip), %rax    # 0x47b9fc
jmp 0x1b7d9c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7d81
leaq 0x1cf191(%rip), %rax    # 0x386f10
jmp 0x1b7d9c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7d95
leaq 0x84be9(%rip), %rax     # 0x23c97c
jmp 0x1b7d9c
leaq 0xc302c(%rip), %rax     # 0x27adc8
movq %rax, 0x583ddd(%rip)    # 0x73bb80
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_32_pointer = parasail_sw_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_32_pointer = parasail_sw_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_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 0x5672cf
testl %eax, %eax
je 0x1b7df6
leaq 0x2c7350(%rip), %rax    # 0x47f144
jmp 0x1b7e25
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7e0a
leaq 0x1d2680(%rip), %rax    # 0x38a488
jmp 0x1b7e25
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7e1e
leaq 0x84b60(%rip), %rax     # 0x23c97c
jmp 0x1b7e25
leaq 0xc6c97(%rip), %rax     # 0x27eabc
movq %rax, 0x583d5c(%rip)    # 0x73bb88
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_16_pointer = parasail_sw_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_16_pointer = parasail_sw_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_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 0x5672cf
testl %eax, %eax
je 0x1b7e7f
leaq 0x2cb22b(%rip), %rax    # 0x4830a8
jmp 0x1b7eae
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7e93
leaq 0x1d5ce7(%rip), %rax    # 0x38db78
jmp 0x1b7eae
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7ea7
leaq 0x84ad7(%rip), %rax     # 0x23c97c
jmp 0x1b7eae
leaq 0xca69a(%rip), %rax     # 0x282548
movq %rax, 0x583cdb(%rip)    # 0x73bb90
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_diag_8_pointer = parasail_sw_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_diag_8_pointer = parasail_sw_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_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 0x5672cf
testl %eax, %eax
je 0x1b7f08
leaq 0x2cffce(%rip), %rax    # 0x487ed4
jmp 0x1b7f37
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7f1c
leaq 0x1d9c1e(%rip), %rax    # 0x391b38
jmp 0x1b7f37
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7f30
leaq 0x84a4e(%rip), %rax     # 0x23c97c
jmp 0x1b7f37
leaq 0xcf1c1(%rip), %rax     # 0x2870f8
movq %rax, 0x583c5a(%rip)    # 0x73bb98
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_64_pointer = parasail_sw_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_64_pointer = parasail_sw_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b7f91
leaq 0x2e1a1d(%rip), %rax    # 0x4999ac
jmp 0x1b7fc0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b7fa5
leaq 0x1e9ba9(%rip), %rax    # 0x3a1b4c
jmp 0x1b7fc0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b7fb9
leaq 0x85a31(%rip), %rax     # 0x23d9e8
jmp 0x1b7fc0
leaq 0xe2c30(%rip), %rax     # 0x29abf0
movq %rax, 0x583bd9(%rip)    # 0x73bba0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_32_pointer = parasail_sw_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_32_pointer = parasail_sw_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b801a
leaq 0x2e391c(%rip), %rax    # 0x49b934
jmp 0x1b8049
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b802e
leaq 0x1eb7f4(%rip), %rax    # 0x3a3820
jmp 0x1b8049
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8042
leaq 0x859a8(%rip), %rax     # 0x23d9e8
jmp 0x1b8049
leaq 0xe4d33(%rip), %rax     # 0x29cd7c
movq %rax, 0x583b58(%rip)    # 0x73bba8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_16_pointer = parasail_sw_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_16_pointer = parasail_sw_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b80a3
leaq 0x2e5a83(%rip), %rax    # 0x49db24
jmp 0x1b80d2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b80b7
leaq 0x1ed62b(%rip), %rax    # 0x3a56e0
jmp 0x1b80d2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b80cb
leaq 0x8591f(%rip), %rax     # 0x23d9e8
jmp 0x1b80d2
leaq 0xe6cb2(%rip), %rax     # 0x29ed84
movq %rax, 0x583ad7(%rip)    # 0x73bbb0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_scan_8_pointer = parasail_sw_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_scan_8_pointer = parasail_sw_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b812c
leaq 0x2e808e(%rip), %rax    # 0x4a01b8
jmp 0x1b815b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8140
leaq 0x1ef716(%rip), %rax    # 0x3a7854
jmp 0x1b815b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8154
leaq 0x85896(%rip), %rax     # 0x23d9e8
jmp 0x1b815b
leaq 0xe91d1(%rip), %rax     # 0x2a132c
movq %rax, 0x583a56(%rip)    # 0x73bbb8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_64_pointer = parasail_sw_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_64_pointer = parasail_sw_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b81b5
leaq 0x2f97b1(%rip), %rax    # 0x4b1964
jmp 0x1b81e4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b81c9
leaq 0x1fc019(%rip), %rax    # 0x3b41e0
jmp 0x1b81e4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b81dd
leaq 0x847a1(%rip), %rax     # 0x23c97c
jmp 0x1b81e4
leaq 0xf77d4(%rip), %rax     # 0x2af9b8
movq %rax, 0x5839d5(%rip)    # 0x73bbc0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_32_pointer = parasail_sw_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_32_pointer = parasail_sw_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b823e
leaq 0x2fb830(%rip), %rax    # 0x4b3a6c
jmp 0x1b826d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8252
leaq 0x1fdf0c(%rip), %rax    # 0x3b615c
jmp 0x1b826d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8266
leaq 0x84718(%rip), %rax     # 0x23c97c
jmp 0x1b826d
leaq 0xf9a7b(%rip), %rax     # 0x2b1ce8
movq %rax, 0x583954(%rip)    # 0x73bbc8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_16_pointer = parasail_sw_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_16_pointer = parasail_sw_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_striped_16_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b82c7
leaq 0x2fdb4f(%rip), %rax    # 0x4b5e14
jmp 0x1b82f6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b82db
leaq 0x1fff17(%rip), %rax    # 0x3b81f0
jmp 0x1b82f6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b82ef
leaq 0x8468f(%rip), %rax     # 0x23c97c
jmp 0x1b82f6
leaq 0xfbb82(%rip), %rax     # 0x2b3e78
movq %rax, 0x5838d3(%rip)    # 0x73bbd0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_striped_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_striped_8_pointer = parasail_sw_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_striped_8_pointer = parasail_sw_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_striped_8_pointer = parasail_sw;
    }
    return parasail_sw_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b8350
leaq 0x300452(%rip), %rax    # 0x4b87a0
jmp 0x1b837f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8364
leaq 0x2021fa(%rip), %rax    # 0x3ba55c
jmp 0x1b837f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8378
leaq 0x84606(%rip), %rax     # 0x23c97c
jmp 0x1b837f
leaq 0xfe059(%rip), %rax     # 0x2b63d8
movq %rax, 0x583852(%rip)    # 0x73bbd8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_64_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_64_pointer = parasail_sw_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_64_pointer = parasail_sw_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_table_diag_64_pointer = parasail_sw;
    }
    return parasail_sw_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b83d9
leaq 0x2ea3ed(%rip), %rax    # 0x4a27c4
jmp 0x1b8408
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b83ed
leaq 0x1f1471(%rip), %rax    # 0x3a985c
jmp 0x1b8408
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8401
leaq 0x8457d(%rip), %rax     # 0x23c97c
jmp 0x1b8408
leaq 0xeb710(%rip), %rax     # 0x2a3b18
movq %rax, 0x5837d1(%rip)    # 0x73bbe0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_32_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_32_pointer = parasail_sw_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_32_pointer = parasail_sw_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_table_diag_32_pointer = parasail_sw;
    }
    return parasail_sw_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b8462
leaq 0x2ecbb8(%rip), %rax    # 0x4a5018
jmp 0x1b8491
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8476
leaq 0x1f3314(%rip), %rax    # 0x3ab788
jmp 0x1b8491
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b848a
leaq 0x844f4(%rip), %rax     # 0x23c97c
jmp 0x1b8491
leaq 0xed9d3(%rip), %rax     # 0x2a5e64
movq %rax, 0x583750(%rip)    # 0x73bbe8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_16_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_16_pointer = parasail_sw_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_16_pointer = parasail_sw_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_table_diag_16_pointer = parasail_sw;
    }
    return parasail_sw_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b84eb
leaq 0x2f0317(%rip), %rax    # 0x4a8800
jmp 0x1b851a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b84ff
leaq 0x1f58cf(%rip), %rax    # 0x3addcc
jmp 0x1b851a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8513
leaq 0x8446b(%rip), %rax     # 0x23c97c
jmp 0x1b851a
leaq 0xf0306(%rip), %rax     # 0x2a8820
movq %rax, 0x5836cf(%rip)    # 0x73bbf0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_table_diag_8_dispatcher
parasail_result_t* parasail_sw_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_sw_table_diag_8_pointer = parasail_sw_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_table_diag_8_pointer = parasail_sw_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_table_diag_8_pointer = parasail_sw;
    }
    return parasail_sw_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b8574
leaq 0x2f5b22(%rip), %rax    # 0x4ae094
jmp 0x1b85a3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8588
leaq 0x1f9002(%rip), %rax    # 0x3b1588
jmp 0x1b85a3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b859c
leaq 0x843e2(%rip), %rax     # 0x23c97c
jmp 0x1b85a3
leaq 0xf40bd(%rip), %rax     # 0x2ac660
movq %rax, 0x58364e(%rip)    # 0x73bbf8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_64_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b85fd
leaq 0x304079(%rip), %rax    # 0x4bc674
jmp 0x1b862c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8611
leaq 0x206119(%rip), %rax    # 0x3be728
jmp 0x1b862c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8625
leaq 0x853c5(%rip), %rax     # 0x23d9e8
jmp 0x1b862c
leaq 0x102100(%rip), %rax    # 0x2ba72c
movq %rax, 0x5835cd(%rip)    # 0x73bc00
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_32_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b8686
leaq 0x307e70(%rip), %rax    # 0x4c04f4
jmp 0x1b86b5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b869a
leaq 0x209c00(%rip), %rax    # 0x3c2298
jmp 0x1b86b5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b86ae
leaq 0x8533c(%rip), %rax     # 0x23d9e8
jmp 0x1b86b5
leaq 0x10657b(%rip), %rax    # 0x2bec30
movq %rax, 0x58354c(%rip)    # 0x73bc08
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_16_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b870f
leaq 0x30bbdf(%rip), %rax    # 0x4c42ec
jmp 0x1b873e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8723
leaq 0x20d62f(%rip), %rax    # 0x3c5d50
jmp 0x1b873e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8737
leaq 0x852b3(%rip), %rax     # 0x23d9e8
jmp 0x1b873e
leaq 0x10a46a(%rip), %rax    # 0x2c2ba8
movq %rax, 0x5834cb(%rip)    # 0x73bc10
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sw_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_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sw_stats_table_scan_8_pointer = parasail_sw_scan;
    }
    return parasail_sw_stats_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b8798
leaq 0x30fee6(%rip), %rax    # 0x4c867c
jmp 0x1b87c7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b87ac
leaq 0x21135a(%rip), %rax    # 0x3c9b04
jmp 0x1b87c7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b87c0
leaq 0x8522a(%rip), %rax     # 0x23d9e8
jmp 0x1b87c7
leaq 0x10e689(%rip), %rax    # 0x2c6e50
movq %rax, 0x58344a(%rip)    # 0x73bc18
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sw_stats_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_64_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b8821
leaq 0x3291d5(%rip), %rax    # 0x4e19f4
jmp 0x1b8850
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b8835
leaq 0x226805(%rip), %rax    # 0x3df038
jmp 0x1b8850
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b8849
leaq 0x84135(%rip), %rax     # 0x23c97c
jmp 0x1b8850
leaq 0x126948(%rip), %rax    # 0x2df198
movq %rax, 0x5833c9(%rip)    # 0x73bc20
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_dispatch.c
// Function: parasail_sw_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sw_stats_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sw_stats_table_striped_32_pointer = parasail_sw;
    }
    return parasail_sw_stats_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b88aa
leaq 0x32d0b4(%rip), %rax    # 0x4e595c
jmp 0x1b88d9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b88be
leaq 0x22a480(%rip), %rax    # 0x3e2d3c
jmp 0x1b88d9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b88d2
leaq 0x840ac(%rip), %rax     # 0x23c97c
jmp 0x1b88d9
leaq 0x12ae77(%rip), %rax    # 0x2e3750
movq %rax, 0x583348(%rip)    # 0x73bc28
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