LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_scan_16_dispatcher
parasail_result_t* parasail_sg_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_16_pointer = parasail_sg_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3413
leaq 0x2ea5af(%rip), %rax    # 0x49d9c0
jmp 0x1b3442
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3427
leaq 0x1f2156(%rip), %rax    # 0x3a557b
jmp 0x1b3442
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b343b
leaq 0x8a593(%rip), %rax     # 0x23d9cc
jmp 0x1b3442
leaq 0xeb7dc(%rip), %rax     # 0x29ec1e
movq %rax, 0x588307(%rip)    # 0x73b750
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_dispatch.c
// Function: parasail_sg_table_scan_8_dispatcher
parasail_result_t* parasail_sg_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_8_pointer = parasail_sg_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b349c
leaq 0x2ecbb9(%rip), %rax    # 0x4a0053
jmp 0x1b34cb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b34b0
leaq 0x1f4241(%rip), %rax    # 0x3a76ef
jmp 0x1b34cb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b34c4
leaq 0x8a50a(%rip), %rax     # 0x23d9cc
jmp 0x1b34cb
leaq 0xedcfb(%rip), %rax     # 0x2a11c6
movq %rax, 0x588286(%rip)    # 0x73b758
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_dispatch.c
// Function: parasail_sg_table_striped_64_dispatcher
parasail_result_t* parasail_sg_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_64_pointer = parasail_sg_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3525
leaq 0x2fe2de(%rip), %rax    # 0x4b1801
jmp 0x1b3554
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3539
leaq 0x200b43(%rip), %rax    # 0x3b407a
jmp 0x1b3554
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b354d
leaq 0x89413(%rip), %rax     # 0x23c95e
jmp 0x1b3554
leaq 0xfc2ff(%rip), %rax     # 0x2af853
movq %rax, 0x588205(%rip)    # 0x73b760
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_dispatch.c
// Function: parasail_sg_table_striped_32_dispatcher
parasail_result_t* parasail_sg_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_32_pointer = parasail_sg_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b35ae
leaq 0x30035c(%rip), %rax    # 0x4b3908
jmp 0x1b35dd
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b35c2
leaq 0x202a38(%rip), %rax    # 0x3b5ff8
jmp 0x1b35dd
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b35d6
leaq 0x8938a(%rip), %rax     # 0x23c95e
jmp 0x1b35dd
leaq 0xfe5a6(%rip), %rax     # 0x2b1b83
movq %rax, 0x588184(%rip)    # 0x73b768
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_dispatch.c
// Function: parasail_sg_table_striped_16_dispatcher
parasail_result_t* parasail_sg_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_16_pointer = parasail_sg_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3637
leaq 0x30267a(%rip), %rax    # 0x4b5caf
jmp 0x1b3666
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b364b
leaq 0x204a42(%rip), %rax    # 0x3b808b
jmp 0x1b3666
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b365f
leaq 0x89301(%rip), %rax     # 0x23c95e
jmp 0x1b3666
leaq 0x1006ae(%rip), %rax    # 0x2b3d14
movq %rax, 0x588103(%rip)    # 0x73b770
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_dispatch.c
// Function: parasail_sg_table_striped_8_dispatcher
parasail_result_t* parasail_sg_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_striped_8_pointer = parasail_sg_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b36c0
leaq 0x304f7e(%rip), %rax    # 0x4b863c
jmp 0x1b36ef
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b36d4
leaq 0x206d27(%rip), %rax    # 0x3ba3f9
jmp 0x1b36ef
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b36e8
leaq 0x89278(%rip), %rax     # 0x23c95e
jmp 0x1b36ef
leaq 0x102b84(%rip), %rax    # 0x2b6273
movq %rax, 0x588082(%rip)    # 0x73b778
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_dispatch.c
// Function: parasail_sg_table_diag_64_dispatcher
parasail_result_t* parasail_sg_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_64_pointer = parasail_sg_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3749
leaq 0x2ef060(%rip), %rax    # 0x4a27a7
jmp 0x1b3778
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b375d
leaq 0x1f60e6(%rip), %rax    # 0x3a9841
jmp 0x1b3778
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3771
leaq 0x891ef(%rip), %rax     # 0x23c95e
jmp 0x1b3778
leaq 0xf0383(%rip), %rax     # 0x2a3afb
movq %rax, 0x588001(%rip)    # 0x73b780
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_dispatch.c
// Function: parasail_sg_table_diag_32_dispatcher
parasail_result_t* parasail_sg_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_32_pointer = parasail_sg_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b37d2
leaq 0x2f182b(%rip), %rax    # 0x4a4ffb
jmp 0x1b3801
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b37e6
leaq 0x1f7f89(%rip), %rax    # 0x3ab76d
jmp 0x1b3801
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b37fa
leaq 0x89166(%rip), %rax     # 0x23c95e
jmp 0x1b3801
leaq 0xf2648(%rip), %rax     # 0x2a5e49
movq %rax, 0x587f80(%rip)    # 0x73b788
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_dispatch.c
// Function: parasail_sg_table_diag_16_dispatcher
parasail_result_t* parasail_sg_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_16_pointer = parasail_sg_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_table_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b385b
leaq 0x2f4f89(%rip), %rax    # 0x4a87e2
jmp 0x1b388a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b386f
leaq 0x1fa542(%rip), %rax    # 0x3addaf
jmp 0x1b388a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3883
leaq 0x890dd(%rip), %rax     # 0x23c95e
jmp 0x1b388a
leaq 0xf4f79(%rip), %rax     # 0x2a8803
movq %rax, 0x587eff(%rip)    # 0x73b790
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_dispatch.c
// Function: parasail_sg_table_diag_8_dispatcher
parasail_result_t* parasail_sg_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_diag_8_pointer = parasail_sg_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_table_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b38e4
leaq 0x2fa795(%rip), %rax    # 0x4ae077
jmp 0x1b3913
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b38f8
leaq 0x1fdc75(%rip), %rax    # 0x3b156b
jmp 0x1b3913
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b390c
leaq 0x89054(%rip), %rax     # 0x23c95e
jmp 0x1b3913
leaq 0xf8d31(%rip), %rax     # 0x2ac644
movq %rax, 0x587e7e(%rip)    # 0x73b798
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_dispatch.c
// Function: parasail_sg_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b396d
leaq 0x308ba5(%rip), %rax    # 0x4bc510
jmp 0x1b399c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3981
leaq 0x20ac43(%rip), %rax    # 0x3be5c2
jmp 0x1b399c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3995
leaq 0x8a039(%rip), %rax     # 0x23d9cc
jmp 0x1b399c
leaq 0x106c2b(%rip), %rax    # 0x2ba5c7
movq %rax, 0x587dfd(%rip)    # 0x73b7a0
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_dispatch.c
// Function: parasail_sg_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b39f6
leaq 0x30c99b(%rip), %rax    # 0x4c038f
jmp 0x1b3a25
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3a0a
leaq 0x20e72b(%rip), %rax    # 0x3c2133
jmp 0x1b3a25
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3a1e
leaq 0x89fb0(%rip), %rax     # 0x23d9cc
jmp 0x1b3a25
leaq 0x10b0a5(%rip), %rax    # 0x2beaca
movq %rax, 0x587d7c(%rip)    # 0x73b7a8
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_dispatch.c
// Function: parasail_sg_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3a7f
leaq 0x31070a(%rip), %rax    # 0x4c4187
jmp 0x1b3aae
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3a93
leaq 0x212159(%rip), %rax    # 0x3c5bea
jmp 0x1b3aae
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3aa7
leaq 0x89f27(%rip), %rax     # 0x23d9cc
jmp 0x1b3aae
leaq 0x10ef95(%rip), %rax    # 0x2c2a43
movq %rax, 0x587cfb(%rip)    # 0x73b7b0
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_dispatch.c
// Function: parasail_sg_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_stats_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3b08
leaq 0x314a10(%rip), %rax    # 0x4c8516
jmp 0x1b3b37
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3b1c
leaq 0x215e87(%rip), %rax    # 0x3c99a1
jmp 0x1b3b37
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3b30
leaq 0x89e9e(%rip), %rax     # 0x23d9cc
jmp 0x1b3b37
leaq 0x1131b4(%rip), %rax    # 0x2c6ceb
movq %rax, 0x587c7a(%rip)    # 0x73b7b8
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_dispatch.c
// Function: parasail_sg_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3b91
leaq 0x32dcff(%rip), %rax    # 0x4e188e
jmp 0x1b3bc0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3ba5
leaq 0x22b330(%rip), %rax    # 0x3deed3
jmp 0x1b3bc0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3bb9
leaq 0x88da7(%rip), %rax     # 0x23c95e
jmp 0x1b3bc0
leaq 0x12b473(%rip), %rax    # 0x2df033
movq %rax, 0x587bf9(%rip)    # 0x73b7c0
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_dispatch.c
// Function: parasail_sg_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3c1a
leaq 0x331bde(%rip), %rax    # 0x4e57f6
jmp 0x1b3c49
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3c2e
leaq 0x22efab(%rip), %rax    # 0x3e2bd7
jmp 0x1b3c49
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3c42
leaq 0x88d1e(%rip), %rax     # 0x23c95e
jmp 0x1b3c49
leaq 0x12f9a4(%rip), %rax    # 0x2e35ed
movq %rax, 0x587b78(%rip)    # 0x73b7c8
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_dispatch.c
// Function: parasail_sg_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3ca3
leaq 0x335c8d(%rip), %rax    # 0x4e992e
jmp 0x1b3cd2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3cb7
leaq 0x232d8a(%rip), %rax    # 0x3e6a3f
jmp 0x1b3cd2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3ccb
leaq 0x88c95(%rip), %rax     # 0x23c95e
jmp 0x1b3cd2
leaq 0x133ae6(%rip), %rax    # 0x2e77b8
movq %rax, 0x587af7(%rip)    # 0x73b7d0
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_dispatch.c
// Function: parasail_sg_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_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_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3d2c
leaq 0x33a39d(%rip), %rax    # 0x4ee0c7
jmp 0x1b3d5b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3d40
leaq 0x236eb4(%rip), %rax    # 0x3eabf2
jmp 0x1b3d5b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3d54
leaq 0x88c0c(%rip), %rax     # 0x23c95e
jmp 0x1b3d5b
leaq 0x138038(%rip), %rax    # 0x2ebd93
movq %rax, 0x587a76(%rip)    # 0x73b7d8
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_dispatch.c
// Function: parasail_sg_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_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_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3db5
leaq 0x318b09(%rip), %rax    # 0x4cc8bc
jmp 0x1b3de4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3dc9
leaq 0x219c2e(%rip), %rax    # 0x3cd9f5
jmp 0x1b3de4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3ddd
leaq 0x88b83(%rip), %rax     # 0x23c95e
jmp 0x1b3de4
leaq 0x1178ec(%rip), %rax    # 0x2cb6d0
movq %rax, 0x5879f5(%rip)    # 0x73b7e0
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_dispatch.c
// Function: parasail_sg_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_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_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3e3e
leaq 0x31cb33(%rip), %rax    # 0x4d096f
jmp 0x1b3e6d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3e52
leaq 0x21d71b(%rip), %rax    # 0x3d156b
jmp 0x1b3e6d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3e66
leaq 0x88afa(%rip), %rax     # 0x23c95e
jmp 0x1b3e6d
leaq 0x11bc0d(%rip), %rax    # 0x2cfa7a
movq %rax, 0x587974(%rip)    # 0x73b7e8
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_dispatch.c
// Function: parasail_sg_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_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_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3ec7
leaq 0x321b3d(%rip), %rax    # 0x4d5a02
jmp 0x1b3ef6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3edb
leaq 0x2217ae(%rip), %rax    # 0x3d5687
jmp 0x1b3ef6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3eef
leaq 0x88a71(%rip), %rax     # 0x23c95e
jmp 0x1b3ef6
leaq 0x12010e(%rip), %rax    # 0x2d4004
movq %rax, 0x5878f3(%rip)    # 0x73b7f0
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_dispatch.c
// Function: parasail_sg_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_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_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_table_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_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 0x1b3f50
leaq 0x328736(%rip), %rax    # 0x4dc684
jmp 0x1b3f7f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3f64
leaq 0x2268d3(%rip), %rax    # 0x3da835
jmp 0x1b3f7f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3f78
leaq 0x889e8(%rip), %rax     # 0x23c95e
jmp 0x1b3f7f
leaq 0x125d1a(%rip), %rax    # 0x2d9c99
movq %rax, 0x587872(%rip)    # 0x73b7f8
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