LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_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_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_scan_8_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_stats_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 0x1e7860
leaq 0x2907c0(%rip), %rax    # 0x47801e
jmp 0x1e788f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7874
leaq 0x19bd8e(%rip), %rax    # 0x383600
jmp 0x1e788f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7888
leaq 0x56129(%rip), %rax     # 0x23d9af
jmp 0x1e788f
leaq 0x8f19a(%rip), %rax     # 0x276a29
movq %rax, 0x556e82(%rip)    # 0x73e718
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_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_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_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 0x1e78e9
leaq 0x2a477c(%rip), %rax    # 0x48c063
jmp 0x1e7918
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e78fd
leaq 0x1adf6a(%rip), %rax    # 0x395865
jmp 0x1e7918
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7911
leaq 0x55032(%rip), %rax     # 0x23c941
jmp 0x1e7918
leaq 0xa4313(%rip), %rax     # 0x28bc2b
movq %rax, 0x556e01(%rip)    # 0x73e720
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_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_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_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 0x1e7972
leaq 0x2a7b0f(%rip), %rax    # 0x48f47f
jmp 0x1e79a1
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7986
leaq 0x1b13c4(%rip), %rax    # 0x398d48
jmp 0x1e79a1
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e799a
leaq 0x54fa9(%rip), %rax     # 0x23c941
jmp 0x1e79a1
leaq 0xa7fcc(%rip), %rax     # 0x28f96d
movq %rax, 0x556d80(%rip)    # 0x73e728
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_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_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_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 0x1e79fb
leaq 0x2aabc1(%rip), %rax    # 0x4925ba
jmp 0x1e7a2a
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7a0f
leaq 0x1b45c7(%rip), %rax    # 0x39bfd4
jmp 0x1e7a2a
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7a23
leaq 0x54f20(%rip), %rax     # 0x23c941
jmp 0x1e7a2a
leaq 0xab53f(%rip), %rax     # 0x292f69
movq %rax, 0x556cff(%rip)    # 0x73e730
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_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_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_striped_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_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 0x1e7a84
leaq 0x2add65(%rip), %rax    # 0x4957e7
jmp 0x1e7ab3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7a98
leaq 0x1b7816(%rip), %rax    # 0x39f2ac
jmp 0x1e7ab3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7aac
leaq 0x54e97(%rip), %rax     # 0x23c941
jmp 0x1e7ab3
leaq 0xaecf8(%rip), %rax     # 0x2967ab
movq %rax, 0x556c7e(%rip)    # 0x73e738
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e7b0d
leaq 0x293eb7(%rip), %rax    # 0x47b9c2
jmp 0x1e7b3c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7b21
leaq 0x19f3b6(%rip), %rax    # 0x386ed5
jmp 0x1e7b3c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7b35
leaq 0x54e0e(%rip), %rax     # 0x23c941
jmp 0x1e7b3c
leaq 0x93251(%rip), %rax     # 0x27ad8d
movq %rax, 0x556bfd(%rip)    # 0x73e740
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e7b96
leaq 0x297577(%rip), %rax    # 0x47f10b
jmp 0x1e7bc5
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7baa
leaq 0x1a28a7(%rip), %rax    # 0x38a44f
jmp 0x1e7bc5
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7bbe
leaq 0x54d85(%rip), %rax     # 0x23c941
jmp 0x1e7bc5
leaq 0x96ebe(%rip), %rax     # 0x27ea83
movq %rax, 0x556b7c(%rip)    # 0x73e748
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e7c1f
leaq 0x29b453(%rip), %rax    # 0x483070
jmp 0x1e7c4e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7c33
leaq 0x1a5f0d(%rip), %rax    # 0x38db3e
jmp 0x1e7c4e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7c47
leaq 0x54cfc(%rip), %rax     # 0x23c941
jmp 0x1e7c4e
leaq 0x9a8c1(%rip), %rax     # 0x28250f
movq %rax, 0x556afb(%rip)    # 0x73e750
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_de_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_diag_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1e7ca8
leaq 0x2a01f6(%rip), %rax    # 0x487e9c
jmp 0x1e7cd7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7cbc
leaq 0x1a9e46(%rip), %rax    # 0x391b00
jmp 0x1e7cd7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7cd0
leaq 0x54c73(%rip), %rax     # 0x23c941
jmp 0x1e7cd7
leaq 0x9f3e8(%rip), %rax     # 0x2870bf
movq %rax, 0x556a7a(%rip)    # 0x73e758
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_64_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x1e7d31
leaq 0x2b1afd(%rip), %rax    # 0x49982c
jmp 0x1e7d60
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7d45
leaq 0x1b9c89(%rip), %rax    # 0x3a19cc
jmp 0x1e7d60
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7d59
leaq 0x55c58(%rip), %rax     # 0x23d9af
jmp 0x1e7d60
leaq 0xb2d10(%rip), %rax     # 0x29aa70
movq %rax, 0x5569f9(%rip)    # 0x73e760
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_32_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x1e7dba
leaq 0x2b39fb(%rip), %rax    # 0x49b7b3
jmp 0x1e7de9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7dce
leaq 0x1bb8d3(%rip), %rax    # 0x3a369f
jmp 0x1e7de9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7de2
leaq 0x55bcf(%rip), %rax     # 0x23d9af
jmp 0x1e7de9
leaq 0xb4e10(%rip), %rax     # 0x29cbf9
movq %rax, 0x556978(%rip)    # 0x73e768
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_16_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x1e7e43
leaq 0x2b5b62(%rip), %rax    # 0x49d9a3
jmp 0x1e7e72
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7e57
leaq 0x1bd709(%rip), %rax    # 0x3a555e
jmp 0x1e7e72
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7e6b
leaq 0x55b46(%rip), %rax     # 0x23d9af
jmp 0x1e7e72
leaq 0xb6d8f(%rip), %rax     # 0x29ec01
movq %rax, 0x5568f7(%rip)    # 0x73e770
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_scan_8_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x1e7ecc
leaq 0x2b816c(%rip), %rax    # 0x4a0036
jmp 0x1e7efb
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7ee0
leaq 0x1bf7f4(%rip), %rax    # 0x3a76d2
jmp 0x1e7efb
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7ef4
leaq 0x55abd(%rip), %rax     # 0x23d9af
jmp 0x1e7efb
leaq 0xb92ae(%rip), %rax     # 0x2a11a9
movq %rax, 0x556876(%rip)    # 0x73e778
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e7f55
leaq 0x2c9891(%rip), %rax    # 0x4b17e4
jmp 0x1e7f84
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7f69
leaq 0x1cc0f6(%rip), %rax    # 0x3b405d
jmp 0x1e7f84
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e7f7d
leaq 0x549c6(%rip), %rax     # 0x23c941
jmp 0x1e7f84
leaq 0xc78b2(%rip), %rax     # 0x2af836
movq %rax, 0x5567f5(%rip)    # 0x73e780
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e7fde
leaq 0x2cb90f(%rip), %rax    # 0x4b38eb
jmp 0x1e800d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e7ff2
leaq 0x1cdfeb(%rip), %rax    # 0x3b5fdb
jmp 0x1e800d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e8006
leaq 0x5493d(%rip), %rax     # 0x23c941
jmp 0x1e800d
leaq 0xc9b59(%rip), %rax     # 0x2b1b66
movq %rax, 0x556774(%rip)    # 0x73e788
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e8067
leaq 0x2cdc2d(%rip), %rax    # 0x4b5c92
jmp 0x1e8096
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e807b
leaq 0x1cfff5(%rip), %rax    # 0x3b806e
jmp 0x1e8096
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e808f
leaq 0x548b4(%rip), %rax     # 0x23c941
jmp 0x1e8096
leaq 0xcbc61(%rip), %rax     # 0x2b3cf7
movq %rax, 0x5566f3(%rip)    # 0x73e790
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_striped_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e80f0
leaq 0x2d0531(%rip), %rax    # 0x4b861f
jmp 0x1e811f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e8104
leaq 0x1d22da(%rip), %rax    # 0x3ba3dc
jmp 0x1e811f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e8118
leaq 0x5482b(%rip), %rax     # 0x23c941
jmp 0x1e811f
leaq 0xce137(%rip), %rax     # 0x2b6256
movq %rax, 0x556672(%rip)    # 0x73e798
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_64_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e8179
leaq 0x2ba613(%rip), %rax    # 0x4a278a
jmp 0x1e81a8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e818d
leaq 0x1c1699(%rip), %rax    # 0x3a9824
jmp 0x1e81a8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e81a1
leaq 0x547a2(%rip), %rax     # 0x23c941
jmp 0x1e81a8
leaq 0xbb936(%rip), %rax     # 0x2a3ade
movq %rax, 0x5565f1(%rip)    # 0x73e7a0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_32_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e8202
leaq 0x2bcdde(%rip), %rax    # 0x4a4fde
jmp 0x1e8231
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e8216
leaq 0x1c353c(%rip), %rax    # 0x3ab750
jmp 0x1e8231
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e822a
leaq 0x54719(%rip), %rax     # 0x23c941
jmp 0x1e8231
leaq 0xbdbfb(%rip), %rax     # 0x2a5e2c
movq %rax, 0x556570(%rip)    # 0x73e7a8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_16_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e828b
leaq 0x2c053c(%rip), %rax    # 0x4a87c5
jmp 0x1e82ba
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e829f
leaq 0x1c5af5(%rip), %rax    # 0x3add92
jmp 0x1e82ba
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e82b3
leaq 0x54690(%rip), %rax     # 0x23c941
jmp 0x1e82ba
leaq 0xc052c(%rip), %rax     # 0x2a87e6
movq %rax, 0x5564ef(%rip)    # 0x73e7b0
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_de_table_diag_8_pointer = parasail_sg_qe_de;
    }
    return parasail_sg_qe_de_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 0x1e8314
leaq 0x2c5d48(%rip), %rax    # 0x4ae05a
jmp 0x1e8343
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e8328
leaq 0x1c9228(%rip), %rax    # 0x3b154e
jmp 0x1e8343
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e833c
leaq 0x54607(%rip), %rax     # 0x23c941
jmp 0x1e8343
leaq 0xc42e4(%rip), %rax     # 0x2ac627
movq %rax, 0x55646e(%rip)    # 0x73e7b8
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_qe_de_dispatch.c
// Function: parasail_sg_qe_de_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_de_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_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_de_stats_table_scan_64_pointer = parasail_sg_qe_de_scan;
    }
    return parasail_sg_qe_de_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 0x1e839d
leaq 0x2d4158(%rip), %rax    # 0x4bc4f3
jmp 0x1e83cc
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1e83b1
leaq 0x1d61f6(%rip), %rax    # 0x3be5a5
jmp 0x1e83cc
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1e83c5
leaq 0x555ec(%rip), %rax     # 0x23d9af
jmp 0x1e83cc
leaq 0xd21de(%rip), %rax     # 0x2ba5aa
movq %rax, 0x5563ed(%rip)    # 0x73e7c0
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