LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2237db
leaq 0x28f5d3(%rip), %rax    # 0x4b2dac
jmp 0x22380a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2237ef
leaq 0x1a6e8c(%rip), %rax    # 0x3ca679
jmp 0x22380a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223803
leaq 0x762d1(%rip), %rax     # 0x299ad2
jmp 0x22380a
leaq 0xb3a8c(%rip), %rax     # 0x2d7296
movq %rax, 0x58009f(%rip)    # 0x7a38b0
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223864
leaq 0x2948d6(%rip), %rax    # 0x4b8138
jmp 0x223893
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223878
leaq 0x1aaf1c(%rip), %rax    # 0x3ce792
jmp 0x223893
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22388c
leaq 0x76248(%rip), %rax     # 0x299ad2
jmp 0x223893
leaq 0xb8267(%rip), %rax     # 0x2dbafa
movq %rax, 0x58001e(%rip)    # 0x7a38b8
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2238ed
leaq 0x2a506e(%rip), %rax    # 0x4c8959
jmp 0x22391c
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223901
leaq 0x1b9135(%rip), %rax    # 0x3dca34
jmp 0x22391c
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223915
leaq 0x7703d(%rip), %rax     # 0x29a950
jmp 0x22391c
leaq 0xc8d82(%rip), %rax     # 0x2ec69e
movq %rax, 0x57ff9d(%rip)    # 0x7a38c0
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223976
leaq 0x2a6f7f(%rip), %rax    # 0x4ca8f3
jmp 0x2239a5
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22398a
leaq 0x1baa31(%rip), %rax    # 0x3de3b9
jmp 0x2239a5
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22399e
leaq 0x76fb4(%rip), %rax     # 0x29a950
jmp 0x2239a5
leaq 0xca8df(%rip), %rax     # 0x2ee284
movq %rax, 0x57ff1c(%rip)    # 0x7a38c8
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2239ff
leaq 0x2a8d93(%rip), %rax    # 0x4cc790
jmp 0x223a2e
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223a13
leaq 0x1bc467(%rip), %rax    # 0x3dfe78
jmp 0x223a2e
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223a27
leaq 0x76f2b(%rip), %rax     # 0x29a950
jmp 0x223a2e
leaq 0xcc424(%rip), %rax     # 0x2efe52
movq %rax, 0x57fe9b(%rip)    # 0x7a38d0
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223a88
leaq 0x2ab0b2(%rip), %rax    # 0x4ceb38
jmp 0x223ab7
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223a9c
leaq 0x1be2a0(%rip), %rax    # 0x3e1d3a
jmp 0x223ab7
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223ab0
leaq 0x76ea2(%rip), %rax     # 0x29a950
jmp 0x223ab7
leaq 0xce565(%rip), %rax     # 0x2f201c
movq %rax, 0x57fe1a(%rip)    # 0x7a38d8
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223b11
leaq 0x2bc402(%rip), %rax    # 0x4dff11
jmp 0x223b40
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223b25
leaq 0x1c9f50(%rip), %rax    # 0x3eda73
jmp 0x223b40
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223b39
leaq 0x75f9b(%rip), %rax     # 0x299ad2
jmp 0x223b40
leaq 0xdb297(%rip), %rax     # 0x2fedd7
movq %rax, 0x57fd99(%rip)    # 0x7a38e0
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223b9a
leaq 0x2bdf56(%rip), %rax    # 0x4e1aee
jmp 0x223bc9
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223bae
leaq 0x1cb6ed(%rip), %rax    # 0x3ef299
jmp 0x223bc9
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223bc2
leaq 0x75f12(%rip), %rax     # 0x299ad2
jmp 0x223bc9
leaq 0xdcc81(%rip), %rax     # 0x30084a
movq %rax, 0x57fd18(%rip)    # 0x7a38e8
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223c23
leaq 0x2bfec4(%rip), %rax    # 0x4e3ae5
jmp 0x223c52
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223c37
leaq 0x1ccfd0(%rip), %rax    # 0x3f0c05
jmp 0x223c52
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223c4b
leaq 0x75e89(%rip), %rax     # 0x299ad2
jmp 0x223c52
leaq 0xde629(%rip), %rax     # 0x30227b
movq %rax, 0x57fc97(%rip)    # 0x7a38f0
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223cac
leaq 0x2c24cf(%rip), %rax    # 0x4e6179
jmp 0x223cdb
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223cc0
leaq 0x1cef1f(%rip), %rax    # 0x3f2bdd
jmp 0x223cdb
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223cd4
leaq 0x75e00(%rip), %rax     # 0x299ad2
jmp 0x223cdb
leaq 0xe0941(%rip), %rax     # 0x30461c
movq %rax, 0x57fc16(%rip)    # 0x7a38f8
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223d35
leaq 0x2ad647(%rip), %rax    # 0x4d137a
jmp 0x223d64
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223d49
leaq 0x1bfeff(%rip), %rax    # 0x3e3c46
jmp 0x223d64
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223d5d
leaq 0x75d77(%rip), %rax     # 0x299ad2
jmp 0x223d64
leaq 0xd05b0(%rip), %rax     # 0x2f4314
movq %rax, 0x57fb95(%rip)    # 0x7a3900
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223dbe
leaq 0x2afd82(%rip), %rax    # 0x4d3b3e
jmp 0x223ded
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223dd2
leaq 0x1c1bee(%rip), %rax    # 0x3e59be
jmp 0x223ded
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223de6
leaq 0x75cee(%rip), %rax     # 0x299ad2
jmp 0x223ded
leaq 0xd262e(%rip), %rax     # 0x2f641b
movq %rax, 0x57fb14(%rip)    # 0x7a3908
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223e47
leaq 0x2b317d(%rip), %rax    # 0x4d6fc2
jmp 0x223e76
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223e5b
leaq 0x1c3fa3(%rip), %rax    # 0x3e7dfc
jmp 0x223e76
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223e6f
leaq 0x75c65(%rip), %rax     # 0x299ad2
jmp 0x223e76
leaq 0xd4c8a(%rip), %rax     # 0x2f8b00
movq %rax, 0x57fa93(%rip)    # 0x7a3910
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223ed0
leaq 0x2b8637(%rip), %rax    # 0x4dc505
jmp 0x223eff
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223ee4
leaq 0x1c7363(%rip), %rax    # 0x3eb245
jmp 0x223eff
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223ef8
leaq 0x75bdc(%rip), %rax     # 0x299ad2
jmp 0x223eff
leaq 0xd8487(%rip), %rax     # 0x2fc386
movq %rax, 0x57fa12(%rip)    # 0x7a3918
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223f59
leaq 0x2c5eaa(%rip), %rax    # 0x4e9e01
jmp 0x223f88
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223f6d
leaq 0x1d2667(%rip), %rax    # 0x3f65d2
jmp 0x223f88
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x223f81
leaq 0x769d1(%rip), %rax     # 0x29a950
jmp 0x223f88
leaq 0xe3d35(%rip), %rax     # 0x307cbd
movq %rax, 0x57f991(%rip)    # 0x7a3920
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x223fe2
leaq 0x2c997d(%rip), %rax    # 0x4ed95d
jmp 0x224011
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x223ff6
leaq 0x1d5afe(%rip), %rax    # 0x3f9af2
jmp 0x224011
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22400a
leaq 0x76948(%rip), %rax     # 0x29a950
jmp 0x224011
leaq 0xe77b6(%rip), %rax     # 0x30b7c7
movq %rax, 0x57f910(%rip)    # 0x7a3928
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22406b
leaq 0x2cd746(%rip), %rax    # 0x4f17af
jmp 0x22409a
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22407f
leaq 0x1d91f7(%rip), %rax    # 0x3fd274
jmp 0x22409a
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224093
leaq 0x768bf(%rip), %rax     # 0x29a950
jmp 0x22409a
leaq 0xeb30c(%rip), %rax     # 0x30f3a6
movq %rax, 0x57f88f(%rip)    # 0x7a3930
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x2240f4
leaq 0x2d1995(%rip), %rax    # 0x4f5a87
jmp 0x224123
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224108
leaq 0x1dd157(%rip), %rax    # 0x40125d
jmp 0x224123
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22411c
leaq 0x76836(%rip), %rax     # 0x29a950
jmp 0x224123
leaq 0xef7c9(%rip), %rax     # 0x3138ec
movq %rax, 0x57f80e(%rip)    # 0x7a3938
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22417d
leaq 0x2ec49c(%rip), %rax    # 0x510617
jmp 0x2241ac
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x224191
leaq 0x1f1ffa(%rip), %rax    # 0x416189
jmp 0x2241ac
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2241a5
leaq 0x7592f(%rip), %rax     # 0x299ad2
jmp 0x2241ac
leaq 0x106391(%rip), %rax    # 0x32a53d
movq %rax, 0x57f78d(%rip)    # 0x7a3940
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224206
leaq 0x2efd46(%rip), %rax    # 0x513f4a
jmp 0x224235
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22421a
leaq 0x1f529d(%rip), %rax    # 0x4194b5
jmp 0x224235
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x22422e
leaq 0x758a6(%rip), %rax     # 0x299ad2
jmp 0x224235
leaq 0x109cf3(%rip), %rax    # 0x32df28
movq %rax, 0x57f70c(%rip)    # 0x7a3948
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x22428f
leaq 0x2f43f4(%rip), %rax    # 0x518681
jmp 0x2242be
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x2242a3
leaq 0x1f8c03(%rip), %rax    # 0x41cea4
jmp 0x2242be
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x2242b7
leaq 0x7581d(%rip), %rax     # 0x299ad2
jmp 0x2242be
leaq 0x10d97f(%rip), %rax    # 0x331c3d
movq %rax, 0x57f68b(%rip)    # 0x7a3950
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_O1/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x594f9c
testl %eax, %eax
je 0x224318
leaq 0x2f8e65(%rip), %rax    # 0x51d17b
jmp 0x224347
xorl %eax, %eax
callq 0x594fc5
testl %eax, %eax
je 0x22432c
leaq 0x1fd8ee(%rip), %rax    # 0x421c18
jmp 0x224347
xorl %eax, %eax
callq 0x594ffe
testl %eax, %eax
jne 0x224340
leaq 0x75794(%rip), %rax     # 0x299ad2
jmp 0x224347
leaq 0x112a35(%rip), %rax    # 0x336d7c
movq %rax, 0x57f60a(%rip)    # 0x7a3958
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