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_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d5ebe
leaq 0x3419b1(%rip), %rax    # 0x51786d
jmp 0x1d5eed
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5ed2
leaq 0x237567(%rip), %rax    # 0x40d437
jmp 0x1d5eed
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5ee6
leaq 0x67a57(%rip), %rax     # 0x23d93b
jmp 0x1d5eed
leaq 0x13c845(%rip), %rax    # 0x312732
movq %rax, 0x567814(%rip)    # 0x73d708
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_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d5f47
leaq 0x3455e7(%rip), %rax    # 0x51b52c
jmp 0x1d5f76
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5f5b
leaq 0x23afcf(%rip), %rax    # 0x410f28
jmp 0x1d5f76
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5f6f
leaq 0x679ce(%rip), %rax     # 0x23d93b
jmp 0x1d5f76
leaq 0x140732(%rip), %rax    # 0x3166a8
movq %rax, 0x567793(%rip)    # 0x73d710
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_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_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 0x1d5fd0
leaq 0x34960f(%rip), %rax    # 0x51f5dd
jmp 0x1d5fff
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d5fe4
leaq 0x23ec62(%rip), %rax    # 0x414c44
jmp 0x1d5fff
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d5ff8
leaq 0x67945(%rip), %rax     # 0x23d93b
jmp 0x1d5fff
leaq 0x144956(%rip), %rax    # 0x31a955
movq %rax, 0x567712(%rip)    # 0x73d718
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_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d6059
leaq 0x362ed6(%rip), %rax    # 0x538f2d
jmp 0x1d6088
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d606d
leaq 0x2543bc(%rip), %rax    # 0x42a427
jmp 0x1d6088
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6081
leaq 0x6684e(%rip), %rax     # 0x23c8cd
jmp 0x1d6088
leaq 0x15cfad(%rip), %rax    # 0x333035
movq %rax, 0x567691(%rip)    # 0x73d720
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_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d60e2
leaq 0x366977(%rip), %rax    # 0x53ca57
jmp 0x1d6111
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d60f6
leaq 0x257d6a(%rip), %rax    # 0x42de5e
jmp 0x1d6111
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d610a
leaq 0x667c5(%rip), %rax     # 0x23c8cd
jmp 0x1d6111
leaq 0x1611c4(%rip), %rax    # 0x3372d5
movq %rax, 0x567610(%rip)    # 0x73d728
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_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d616b
leaq 0x36a309(%rip), %rax    # 0x540472
jmp 0x1d619a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d617f
leaq 0x25b52d(%rip), %rax    # 0x4316aa
jmp 0x1d619a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6193
leaq 0x6673c(%rip), %rax     # 0x23c8cd
jmp 0x1d619a
leaq 0x164e39(%rip), %rax    # 0x33afd3
movq %rax, 0x56758f(%rip)    # 0x73d730
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_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d61f4
leaq 0x36e1b2(%rip), %rax    # 0x5443a4
jmp 0x1d6223
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d6208
leaq 0x25efbd(%rip), %rax    # 0x4351c3
jmp 0x1d6223
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d621c
leaq 0x666b3(%rip), %rax     # 0x23c8cd
jmp 0x1d6223
leaq 0x168da2(%rip), %rax    # 0x33efc5
movq %rax, 0x56750e(%rip)    # 0x73d738
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_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_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_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_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 0x1d627d
leaq 0x34d6a1(%rip), %rax    # 0x52391c
jmp 0x1d62ac
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d6291
leaq 0x242a41(%rip), %rax    # 0x418cd0
jmp 0x1d62ac
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d62a5
leaq 0x6662a(%rip), %rax     # 0x23c8cd
jmp 0x1d62ac
leaq 0x14910c(%rip), %rax    # 0x31f3b8
movq %rax, 0x56748d(%rip)    # 0x73d740
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_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d6306
leaq 0x351777(%rip), %rax    # 0x527a7b
jmp 0x1d6335
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d631a
leaq 0x2465d3(%rip), %rax    # 0x41c8eb
jmp 0x1d6335
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d632e
leaq 0x665a1(%rip), %rax     # 0x23c8cd
jmp 0x1d6335
leaq 0x14d4c7(%rip), %rax    # 0x3237fc
movq %rax, 0x56740c(%rip)    # 0x73d748
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_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d638f
leaq 0x356952(%rip), %rax    # 0x52ccdf
jmp 0x1d63be
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d63a3
leaq 0x24a72d(%rip), %rax    # 0x420ace
jmp 0x1d63be
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d63b7
leaq 0x66518(%rip), %rax     # 0x23c8cd
jmp 0x1d63be
leaq 0x151a7d(%rip), %rax    # 0x327e3b
movq %rax, 0x56738b(%rip)    # 0x73d750
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_diag_8_dispatcher
parasail_result_t* parasail_sg_dx_stats_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_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_stats_rowcol_diag_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_stats_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 0x1d6418
leaq 0x35d83b(%rip), %rax    # 0x533c51
jmp 0x1d6447
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d642c
leaq 0x24f93c(%rip), %rax    # 0x425d66
jmp 0x1d6447
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6440
leaq 0x6648f(%rip), %rax     # 0x23c8cd
jmp 0x1d6447
leaq 0x1577d8(%rip), %rax    # 0x32dc1f
movq %rax, 0x56730a(%rip)    # 0x73d758
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_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_scan_64_pointer = parasail_sg_dx_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_64_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_trace_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 0x1d64a1
leaq 0x370f30(%rip), %rax    # 0x5473cf
jmp 0x1d64d0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d64b5
leaq 0x261b09(%rip), %rax    # 0x437fbc
jmp 0x1d64d0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d64c9
leaq 0x67474(%rip), %rax     # 0x23d93b
jmp 0x1d64d0
leaq 0x16c0ae(%rip), %rax    # 0x34257e
movq %rax, 0x567289(%rip)    # 0x73d760
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_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_scan_32_pointer = parasail_sg_dx_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_32_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_trace_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 0x1d652a
leaq 0x372df6(%rip), %rax    # 0x54931e
jmp 0x1d6559
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d653e
leaq 0x26399a(%rip), %rax    # 0x439ed6
jmp 0x1d6559
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6552
leaq 0x673eb(%rip), %rax     # 0x23d93b
jmp 0x1d6559
leaq 0x16e41e(%rip), %rax    # 0x344977
movq %rax, 0x567208(%rip)    # 0x73d768
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_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_scan_16_pointer = parasail_sg_dx_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_16_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_trace_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 0x1d65b3
leaq 0x374b7e(%rip), %rax    # 0x54b12f
jmp 0x1d65e2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d65c7
leaq 0x2657b4(%rip), %rax    # 0x43bd79
jmp 0x1d65e2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d65db
leaq 0x67362(%rip), %rax     # 0x23d93b
jmp 0x1d65e2
leaq 0x1703a0(%rip), %rax    # 0x346982
movq %rax, 0x567187(%rip)    # 0x73d770
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_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_scan_8_pointer = parasail_sg_dx_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_trace_scan_8_pointer = parasail_sg_dx_scan;
    }
    return parasail_sg_dx_trace_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 0x1d663c
leaq 0x3768e2(%rip), %rax    # 0x54cf1c
jmp 0x1d666b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d6650
leaq 0x2675c7(%rip), %rax    # 0x43dc15
jmp 0x1d666b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6664
leaq 0x672d9(%rip), %rax     # 0x23d93b
jmp 0x1d666b
leaq 0x1724b2(%rip), %rax    # 0x348b1d
movq %rax, 0x567106(%rip)    # 0x73d778
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_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_striped_64_pointer = parasail_sg_dx_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_trace_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 0x1d66c5
leaq 0x388b9a(%rip), %rax    # 0x55f25d
jmp 0x1d66f4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d66d9
leaq 0x275119(%rip), %rax    # 0x44b7f0
jmp 0x1d66f4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d66ed
leaq 0x661e2(%rip), %rax     # 0x23c8cd
jmp 0x1d66f4
leaq 0x181a13(%rip), %rax    # 0x358107
movq %rax, 0x567085(%rip)    # 0x73d780
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_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_striped_32_pointer = parasail_sg_dx_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_trace_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 0x1d674e
leaq 0x38b2e9(%rip), %rax    # 0x561a35
jmp 0x1d677d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d6762
leaq 0x277814(%rip), %rax    # 0x44df74
jmp 0x1d677d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6776
leaq 0x66159(%rip), %rax     # 0x23c8cd
jmp 0x1d677d
leaq 0x1847b6(%rip), %rax    # 0x35af33
movq %rax, 0x567004(%rip)    # 0x73d788
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_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_striped_16_pointer = parasail_sg_dx_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_trace_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 0x1d67d7
leaq 0x38d7c8(%rip), %rax    # 0x563f9d
jmp 0x1d6806
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d67eb
leaq 0x279ce0(%rip), %rax    # 0x4504c9
jmp 0x1d6806
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d67ff
leaq 0x660d0(%rip), %rax     # 0x23c8cd
jmp 0x1d6806
leaq 0x186e26(%rip), %rax    # 0x35d62c
movq %rax, 0x566f83(%rip)    # 0x73d790
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_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_striped_8_pointer = parasail_sg_dx_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_dx_trace_striped_8_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_trace_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 0x1d6860
leaq 0x38fc93(%rip), %rax    # 0x5664f1
jmp 0x1d688f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d6874
leaq 0x27c1e3(%rip), %rax    # 0x452a55
jmp 0x1d688f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6888
leaq 0x66047(%rip), %rax     # 0x23c8cd
jmp 0x1d688f
leaq 0x1896d2(%rip), %rax    # 0x35ff61
movq %rax, 0x566f02(%rip)    # 0x73d798
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_trace_diag_64_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_diag_64_pointer = parasail_sg_dx_trace_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx_trace_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_dx_trace_diag_64_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_trace_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 0x1d68e9
leaq 0x378b9b(%rip), %rax    # 0x54f482
jmp 0x1d6918
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d68fd
leaq 0x269623(%rip), %rax    # 0x43ff1e
jmp 0x1d6918
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6911
leaq 0x65fbe(%rip), %rax     # 0x23c8cd
jmp 0x1d6918
leaq 0x174b62(%rip), %rax    # 0x34b47a
movq %rax, 0x566e81(%rip)    # 0x73d7a0
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_trace_diag_32_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_diag_32_pointer = parasail_sg_dx_trace_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx_trace_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_dx_trace_diag_32_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_trace_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 0x1d6972
leaq 0x37b527(%rip), %rax    # 0x551e97
jmp 0x1d69a1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d6986
leaq 0x26b715(%rip), %rax    # 0x442099
jmp 0x1d69a1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d699a
leaq 0x65f35(%rip), %rax     # 0x23c8cd
jmp 0x1d69a1
leaq 0x177054(%rip), %rax    # 0x34d9f5
movq %rax, 0x566e00(%rip)    # 0x73d7a8
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_trace_diag_16_dispatcher
parasail_result_t* parasail_sg_dx_trace_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_trace_diag_16_pointer = parasail_sg_dx_trace_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx_trace_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_dx_trace_diag_16_pointer = parasail_sg_dx;
    }
    return parasail_sg_dx_trace_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 0x1d69fb
leaq 0x37ee34(%rip), %rax    # 0x55582d
jmp 0x1d6a2a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1d6a0f
leaq 0x26df24(%rip), %rax    # 0x444931
jmp 0x1d6a2a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1d6a23
leaq 0x65eac(%rip), %rax     # 0x23c8cd
jmp 0x1d6a2a
leaq 0x1799c3(%rip), %rax    # 0x3503ed
movq %rax, 0x566d7f(%rip)    # 0x73d7b0
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