LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d52f8
leaq 0x2f318f(%rip), %rax    # 0x4c8485
jmp 0x1d5327
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d530c
leaq 0x1f4606(%rip), %rax    # 0x3c9910
jmp 0x1d5327
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5320
leaq 0x6861d(%rip), %rax     # 0x23d93b
jmp 0x1d5327
leaq 0xf1933(%rip), %rax     # 0x2c6c5a
movq %rax, 0x56832a(%rip)    # 0x73d658
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5381
leaq 0x30c47e(%rip), %rax    # 0x4e17fd
jmp 0x1d53b0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5395
leaq 0x209aaf(%rip), %rax    # 0x3dee42
jmp 0x1d53b0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d53a9
leaq 0x67526(%rip), %rax     # 0x23c8cd
jmp 0x1d53b0
leaq 0x109bf2(%rip), %rax    # 0x2defa2
movq %rax, 0x5682a9(%rip)    # 0x73d660
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d540a
leaq 0x31035d(%rip), %rax    # 0x4e5765
jmp 0x1d5439
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d541e
leaq 0x20d72a(%rip), %rax    # 0x3e2b46
jmp 0x1d5439
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5432
leaq 0x6749d(%rip), %rax     # 0x23c8cd
jmp 0x1d5439
leaq 0x10e123(%rip), %rax    # 0x2e355c
movq %rax, 0x568228(%rip)    # 0x73d668
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d5493
leaq 0x31440c(%rip), %rax    # 0x4e989d
jmp 0x1d54c2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d54a7
leaq 0x211509(%rip), %rax    # 0x3e69ae
jmp 0x1d54c2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d54bb
leaq 0x67414(%rip), %rax     # 0x23c8cd
jmp 0x1d54c2
leaq 0x112265(%rip), %rax    # 0x2e7727
movq %rax, 0x5681a7(%rip)    # 0x73d670
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d551c
leaq 0x318b1c(%rip), %rax    # 0x4ee036
jmp 0x1d554b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5530
leaq 0x215633(%rip), %rax    # 0x3eab61
jmp 0x1d554b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5544
leaq 0x6738b(%rip), %rax     # 0x23c8cd
jmp 0x1d554b
leaq 0x1167b7(%rip), %rax    # 0x2ebd02
movq %rax, 0x568126(%rip)    # 0x73d678
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d55a5
leaq 0x2f7288(%rip), %rax    # 0x4cc82b
jmp 0x1d55d4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d55b9
leaq 0x1f83ad(%rip), %rax    # 0x3cd964
jmp 0x1d55d4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d55cd
leaq 0x67302(%rip), %rax     # 0x23c8cd
jmp 0x1d55d4
leaq 0xf606b(%rip), %rax     # 0x2cb63f
movq %rax, 0x5680a5(%rip)    # 0x73d680
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d562e
leaq 0x2fb2b2(%rip), %rax    # 0x4d08de
jmp 0x1d565d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5642
leaq 0x1fbe9a(%rip), %rax    # 0x3d14da
jmp 0x1d565d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5656
leaq 0x67279(%rip), %rax     # 0x23c8cd
jmp 0x1d565d
leaq 0xfa38c(%rip), %rax     # 0x2cf9e9
movq %rax, 0x568024(%rip)    # 0x73d688
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d56b7
leaq 0x3002bc(%rip), %rax    # 0x4d5971
jmp 0x1d56e6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d56cb
leaq 0x1fff2d(%rip), %rax    # 0x3d55f6
jmp 0x1d56e6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d56df
leaq 0x671f0(%rip), %rax     # 0x23c8cd
jmp 0x1d56e6
leaq 0xfe88d(%rip), %rax     # 0x2d3f73
movq %rax, 0x567fa3(%rip)    # 0x73d690
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_table_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5740
leaq 0x306eb5(%rip), %rax    # 0x4dc5f3
jmp 0x1d576f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5754
leaq 0x205052(%rip), %rax    # 0x3da7a4
jmp 0x1d576f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5768
leaq 0x67167(%rip), %rax     # 0x23c8cd
jmp 0x1d576f
leaq 0x104499(%rip), %rax    # 0x2d9c08
movq %rax, 0x567f22(%rip)    # 0x73d698
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d57c9
leaq 0x31ba66(%rip), %rax    # 0x4f122d
jmp 0x1d57f8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d57dd
leaq 0x21800f(%rip), %rax    # 0x3ed7ea
jmp 0x1d57f8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d57f1
leaq 0x6814c(%rip), %rax     # 0x23d93b
jmp 0x1d57f8
leaq 0x119899(%rip), %rax    # 0x2ef091
movq %rax, 0x567ea1(%rip)    # 0x73d6a0
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d5852
leaq 0x31d8f2(%rip), %rax    # 0x4f3142
jmp 0x1d5881
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5866
leaq 0x219cd3(%rip), %rax    # 0x3ef537
jmp 0x1d5881
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d587a
leaq 0x680c3(%rip), %rax     # 0x23d93b
jmp 0x1d5881
leaq 0x11ba2c(%rip), %rax    # 0x2f12ad
movq %rax, 0x567e20(%rip)    # 0x73d6a8
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d58db
leaq 0x31f991(%rip), %rax    # 0x4f526a
jmp 0x1d590a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d58ef
leaq 0x21bad3(%rip), %rax    # 0x3f13c0
jmp 0x1d590a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5903
leaq 0x6803a(%rip), %rax     # 0x23d93b
jmp 0x1d590a
leaq 0x11d9a0(%rip), %rax    # 0x2f32aa
movq %rax, 0x567d9f(%rip)    # 0x73d6b0
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d5964
leaq 0x321f5d(%rip), %rax    # 0x4f78bf
jmp 0x1d5993
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5978
leaq 0x21db19(%rip), %rax    # 0x3f348f
jmp 0x1d5993
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d598c
leaq 0x67fb1(%rip), %rax     # 0x23d93b
jmp 0x1d5993
leaq 0x11fcb2(%rip), %rax    # 0x2f5645
movq %rax, 0x567d1e(%rip)    # 0x73d6b8
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d59ed
leaq 0x333e90(%rip), %rax    # 0x50987b
jmp 0x1d5a1c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5a01
leaq 0x22a5a7(%rip), %rax    # 0x3fffa6
jmp 0x1d5a1c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5a15
leaq 0x66eba(%rip), %rax     # 0x23c8cd
jmp 0x1d5a1c
leaq 0x12e4b0(%rip), %rax    # 0x303ecc
movq %rax, 0x567c9d(%rip)    # 0x73d6c0
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5a76
leaq 0x335b0a(%rip), %rax    # 0x50b57e
jmp 0x1d5aa5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5a8a
leaq 0x22c105(%rip), %rax    # 0x401b8d
jmp 0x1d5aa5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5a9e
leaq 0x66e31(%rip), %rax     # 0x23c8cd
jmp 0x1d5aa5
leaq 0x130477(%rip), %rax    # 0x305f1c
movq %rax, 0x567c1c(%rip)    # 0x73d6c8
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5aff
leaq 0x337916(%rip), %rax    # 0x50d413
jmp 0x1d5b2e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5b13
leaq 0x22dc93(%rip), %rax    # 0x4037a4
jmp 0x1d5b2e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5b27
leaq 0x66da8(%rip), %rax     # 0x23c8cd
jmp 0x1d5b2e
leaq 0x132143(%rip), %rax    # 0x307c71
movq %rax, 0x567b9b(%rip)    # 0x73d6d0
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5b88
leaq 0x339ce9(%rip), %rax    # 0x50f86f
jmp 0x1d5bb7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5b9c
leaq 0x22fabd(%rip), %rax    # 0x405657
jmp 0x1d5bb7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5bb0
leaq 0x66d1f(%rip), %rax     # 0x23c8cd
jmp 0x1d5bb7
leaq 0x13421d(%rip), %rax    # 0x309dd4
movq %rax, 0x567b1a(%rip)    # 0x73d6d8
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5c11
leaq 0x3244b6(%rip), %rax    # 0x4fa0c5
jmp 0x1d5c40
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5c25
leaq 0x21f9df(%rip), %rax    # 0x3f5602
jmp 0x1d5c40
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5c39
leaq 0x66c96(%rip), %rax     # 0x23c8cd
jmp 0x1d5c40
leaq 0x122219(%rip), %rax    # 0x2f7e59
movq %rax, 0x567a99(%rip)    # 0x73d6e0
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5c9a
leaq 0x326c2c(%rip), %rax    # 0x4fc8c4
jmp 0x1d5cc9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5cae
leaq 0x221812(%rip), %rax    # 0x3f74be
jmp 0x1d5cc9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5cc2
leaq 0x66c0d(%rip), %rax     # 0x23c8cd
jmp 0x1d5cc9
leaq 0x1244d0(%rip), %rax    # 0x2fa199
movq %rax, 0x567a18(%rip)    # 0x73d6e8
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5d23
leaq 0x32a4f4(%rip), %rax    # 0x500215
jmp 0x1d5d52
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5d37
leaq 0x223dea(%rip), %rax    # 0x3f9b1f
jmp 0x1d5d52
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5d4b
leaq 0x66b84(%rip), %rax     # 0x23c8cd
jmp 0x1d5d52
leaq 0x126dd2(%rip), %rax    # 0x2fcb24
movq %rax, 0x567997(%rip)    # 0x73d6f0
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_dx_dispatch.c
// Function: parasail_sg_dx_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_rowcol_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d5dac
leaq 0x330205(%rip), %rax    # 0x505faf
jmp 0x1d5ddb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5dc0
leaq 0x2275e0(%rip), %rax    # 0x3fd39e
jmp 0x1d5ddb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5dd4
leaq 0x66afb(%rip), %rax     # 0x23c8cd
jmp 0x1d5ddb
leaq 0x12ad71(%rip), %rax    # 0x300b4c
movq %rax, 0x567916(%rip)    # 0x73d6f8
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_dx_dispatch.c
// Function: parasail_sg_dx_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d5e35
leaq 0x33da2f(%rip), %rax    # 0x513862
jmp 0x1d5e64
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5e49
leaq 0x23392d(%rip), %rax    # 0x409774
jmp 0x1d5e64
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5e5d
leaq 0x67ae0(%rip), %rax     # 0x23d93b
jmp 0x1d5e64
leaq 0x1382ab(%rip), %rax    # 0x30e10f
movq %rax, 0x567895(%rip)    # 0x73d700
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