LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_de_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_table_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0ab0
leaq 0x30bb29(%rip), %rax    # 0x4dc5d7
jmp 0x1d0adf
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0ac4
leaq 0x209cc6(%rip), %rax    # 0x3da788
jmp 0x1d0adf
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0ad8
leaq 0x6bddb(%rip), %rax     # 0x23c8b1
jmp 0x1d0adf
leaq 0x10910d(%rip), %rax    # 0x2d9bec
movq %rax, 0x56c752(%rip)    # 0x73d238
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_de_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0b39
leaq 0x3206da(%rip), %rax    # 0x4f1211
jmp 0x1d0b68
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0b4d
leaq 0x21cc83(%rip), %rax    # 0x3ed7ce
jmp 0x1d0b68
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0b61
leaq 0x6cdc0(%rip), %rax     # 0x23d91f
jmp 0x1d0b68
leaq 0x11e50d(%rip), %rax    # 0x2ef075
movq %rax, 0x56c6d1(%rip)    # 0x73d240
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_de_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0bc2
leaq 0x322566(%rip), %rax    # 0x4f3126
jmp 0x1d0bf1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0bd6
leaq 0x21e947(%rip), %rax    # 0x3ef51b
jmp 0x1d0bf1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0bea
leaq 0x6cd37(%rip), %rax     # 0x23d91f
jmp 0x1d0bf1
leaq 0x1206a0(%rip), %rax    # 0x2f1291
movq %rax, 0x56c650(%rip)    # 0x73d248
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_de_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0c4b
leaq 0x324605(%rip), %rax    # 0x4f524e
jmp 0x1d0c7a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0c5f
leaq 0x220747(%rip), %rax    # 0x3f13a4
jmp 0x1d0c7a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0c73
leaq 0x6ccae(%rip), %rax     # 0x23d91f
jmp 0x1d0c7a
leaq 0x122614(%rip), %rax    # 0x2f328e
movq %rax, 0x56c5cf(%rip)    # 0x73d250
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_de_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0cd4
leaq 0x326bd1(%rip), %rax    # 0x4f78a3
jmp 0x1d0d03
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0ce8
leaq 0x22278d(%rip), %rax    # 0x3f3473
jmp 0x1d0d03
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0cfc
leaq 0x6cc25(%rip), %rax     # 0x23d91f
jmp 0x1d0d03
leaq 0x124926(%rip), %rax    # 0x2f5629
movq %rax, 0x56c54e(%rip)    # 0x73d258
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_de_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0d5d
leaq 0x338b04(%rip), %rax    # 0x50985f
jmp 0x1d0d8c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0d71
leaq 0x22f21b(%rip), %rax    # 0x3fff8a
jmp 0x1d0d8c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0d85
leaq 0x6bb2e(%rip), %rax     # 0x23c8b1
jmp 0x1d0d8c
leaq 0x133124(%rip), %rax    # 0x303eb0
movq %rax, 0x56c4cd(%rip)    # 0x73d260
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_de_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0de6
leaq 0x33a77e(%rip), %rax    # 0x50b562
jmp 0x1d0e15
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0dfa
leaq 0x230d79(%rip), %rax    # 0x401b71
jmp 0x1d0e15
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0e0e
leaq 0x6baa5(%rip), %rax     # 0x23c8b1
jmp 0x1d0e15
leaq 0x1350eb(%rip), %rax    # 0x305f00
movq %rax, 0x56c44c(%rip)    # 0x73d268
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_de_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0e6f
leaq 0x33c58a(%rip), %rax    # 0x50d3f7
jmp 0x1d0e9e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0e83
leaq 0x232907(%rip), %rax    # 0x403788
jmp 0x1d0e9e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0e97
leaq 0x6ba1c(%rip), %rax     # 0x23c8b1
jmp 0x1d0e9e
leaq 0x136db7(%rip), %rax    # 0x307c55
movq %rax, 0x56c3cb(%rip)    # 0x73d270
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_de_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0ef8
leaq 0x33e95d(%rip), %rax    # 0x50f853
jmp 0x1d0f27
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0f0c
leaq 0x234731(%rip), %rax    # 0x40563b
jmp 0x1d0f27
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0f20
leaq 0x6b993(%rip), %rax     # 0x23c8b1
jmp 0x1d0f27
leaq 0x138e91(%rip), %rax    # 0x309db8
movq %rax, 0x56c34a(%rip)    # 0x73d278
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_de_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d0f81
leaq 0x32912a(%rip), %rax    # 0x4fa0a9
jmp 0x1d0fb0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d0f95
leaq 0x224653(%rip), %rax    # 0x3f55e6
jmp 0x1d0fb0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d0fa9
leaq 0x6b90a(%rip), %rax     # 0x23c8b1
jmp 0x1d0fb0
leaq 0x126e8d(%rip), %rax    # 0x2f7e3d
movq %rax, 0x56c2c9(%rip)    # 0x73d280
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_de_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d100a
leaq 0x32b8a0(%rip), %rax    # 0x4fc8a8
jmp 0x1d1039
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d101e
leaq 0x226486(%rip), %rax    # 0x3f74a2
jmp 0x1d1039
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1032
leaq 0x6b881(%rip), %rax     # 0x23c8b1
jmp 0x1d1039
leaq 0x129144(%rip), %rax    # 0x2fa17d
movq %rax, 0x56c248(%rip)    # 0x73d288
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_de_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1093
leaq 0x32f168(%rip), %rax    # 0x5001f9
jmp 0x1d10c2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d10a7
leaq 0x228a5e(%rip), %rax    # 0x3f9b03
jmp 0x1d10c2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d10bb
leaq 0x6b7f8(%rip), %rax     # 0x23c8b1
jmp 0x1d10c2
leaq 0x12ba46(%rip), %rax    # 0x2fcb08
movq %rax, 0x56c1c7(%rip)    # 0x73d290
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/sg_de_dispatch.c
// Function: parasail_sg_de_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_de_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_rowcol_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d111c
leaq 0x334e79(%rip), %rax    # 0x505f93
jmp 0x1d114b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1130
leaq 0x22c254(%rip), %rax    # 0x3fd382
jmp 0x1d114b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1144
leaq 0x6b76f(%rip), %rax     # 0x23c8b1
jmp 0x1d114b
leaq 0x12f9e5(%rip), %rax    # 0x300b30
movq %rax, 0x56c146(%rip)    # 0x73d298
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d11a5
leaq 0x3426a3(%rip), %rax    # 0x513846
jmp 0x1d11d4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d11b9
leaq 0x2385a1(%rip), %rax    # 0x409758
jmp 0x1d11d4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d11cd
leaq 0x6c754(%rip), %rax     # 0x23d91f
jmp 0x1d11d4
leaq 0x13cf1f(%rip), %rax    # 0x30e0f3
movq %rax, 0x56c0c5(%rip)    # 0x73d2a0
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d122e
leaq 0x346625(%rip), %rax    # 0x517851
jmp 0x1d125d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1242
leaq 0x23c1db(%rip), %rax    # 0x40d41b
jmp 0x1d125d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1256
leaq 0x6c6cb(%rip), %rax     # 0x23d91f
jmp 0x1d125d
leaq 0x1414b9(%rip), %rax    # 0x312716
movq %rax, 0x56c044(%rip)    # 0x73d2a8
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d12b7
leaq 0x34a25b(%rip), %rax    # 0x51b510
jmp 0x1d12e6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d12cb
leaq 0x23fc43(%rip), %rax    # 0x410f0c
jmp 0x1d12e6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d12df
leaq 0x6c642(%rip), %rax     # 0x23d91f
jmp 0x1d12e6
leaq 0x1453a6(%rip), %rax    # 0x31668c
movq %rax, 0x56bfc3(%rip)    # 0x73d2b0
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1340
leaq 0x34e283(%rip), %rax    # 0x51f5c1
jmp 0x1d136f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1354
leaq 0x2438d6(%rip), %rax    # 0x414c28
jmp 0x1d136f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1368
leaq 0x6c5b9(%rip), %rax     # 0x23d91f
jmp 0x1d136f
leaq 0x1495ca(%rip), %rax    # 0x31a939
movq %rax, 0x56bf42(%rip)    # 0x73d2b8
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d13c9
leaq 0x367b4a(%rip), %rax    # 0x538f11
jmp 0x1d13f8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d13dd
leaq 0x259030(%rip), %rax    # 0x42a40b
jmp 0x1d13f8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d13f1
leaq 0x6b4c2(%rip), %rax     # 0x23c8b1
jmp 0x1d13f8
leaq 0x161c21(%rip), %rax    # 0x333019
movq %rax, 0x56bec1(%rip)    # 0x73d2c0
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1452
leaq 0x36b5eb(%rip), %rax    # 0x53ca3b
jmp 0x1d1481
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1466
leaq 0x25c9de(%rip), %rax    # 0x42de42
jmp 0x1d1481
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d147a
leaq 0x6b439(%rip), %rax     # 0x23c8b1
jmp 0x1d1481
leaq 0x165e38(%rip), %rax    # 0x3372b9
movq %rax, 0x56be40(%rip)    # 0x73d2c8
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d14db
leaq 0x36ef7d(%rip), %rax    # 0x540456
jmp 0x1d150a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d14ef
leaq 0x2601a1(%rip), %rax    # 0x43168e
jmp 0x1d150a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1503
leaq 0x6b3b0(%rip), %rax     # 0x23c8b1
jmp 0x1d150a
leaq 0x169aad(%rip), %rax    # 0x33afb7
movq %rax, 0x56bdbf(%rip)    # 0x73d2d0
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d1564
leaq 0x372e26(%rip), %rax    # 0x544388
jmp 0x1d1593
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1578
leaq 0x263c31(%rip), %rax    # 0x4351a7
jmp 0x1d1593
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d158c
leaq 0x6b327(%rip), %rax     # 0x23c8b1
jmp 0x1d1593
leaq 0x16da16(%rip), %rax    # 0x33efa9
movq %rax, 0x56bd3e(%rip)    # 0x73d2d8
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/sg_de_dispatch.c
// Function: parasail_sg_de_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_de_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_rowcol_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1d15ed
leaq 0x352315(%rip), %rax    # 0x523900
jmp 0x1d161c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d1601
leaq 0x2476b5(%rip), %rax    # 0x418cb4
jmp 0x1d161c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d1615
leaq 0x6b29e(%rip), %rax     # 0x23c8b1
jmp 0x1d161c
leaq 0x14dd80(%rip), %rax    # 0x31f39c
movq %rax, 0x56bcbd(%rip)    # 0x73d2e0
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