LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ecd2e
leaq 0x8c083b(%rip), %rax    # 0xaad560
movq %rax, 0xc3b7c4(%rip)    # 0xe284f0
jmp 0x1ecd78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ecd4a
leaq 0x53e04f(%rip), %rax    # 0x72ad90
movq %rax, 0xc3b7a8(%rip)    # 0xe284f0
jmp 0x1ecd76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ecd66
leaq 0x25ae13(%rip), %rax    # 0x447b70
movq %rax, 0xc3b78c(%rip)    # 0xe284f0
jmp 0x1ecd74
leaq 0xaa5d3(%rip), %rax     # 0x297340
movq %rax, 0xc3b77c(%rip)    # 0xe284f0
jmp 0x1ecd76
jmp 0x1ecd78
movq 0xc3b771(%rip), %rax    # 0xe284f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ecdee
leaq 0x8cf5bb(%rip), %rax    # 0xabc3a0
movq %rax, 0xc3b70c(%rip)    # 0xe284f8
jmp 0x1ece38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ece0a
leaq 0x5493ff(%rip), %rax    # 0x736200
movq %rax, 0xc3b6f0(%rip)    # 0xe284f8
jmp 0x1ece36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ece26
leaq 0x265a03(%rip), %rax    # 0x452820
movq %rax, 0xc3b6d4(%rip)    # 0xe284f8
jmp 0x1ece34
leaq 0xaa513(%rip), %rax     # 0x297340
movq %rax, 0xc3b6c4(%rip)    # 0xe284f8
jmp 0x1ece36
jmp 0x1ece38
movq 0xc3b6b9(%rip), %rax    # 0xe284f8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eceae
leaq 0x85fc6b(%rip), %rax    # 0xa4cb10
movq %rax, 0xc3b654(%rip)    # 0xe28500
jmp 0x1ecef8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ececa
leaq 0x4f92bf(%rip), %rax    # 0x6e6180
movq %rax, 0xc3b638(%rip)    # 0xe28500
jmp 0x1ecef6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ecee6
leaq 0x218193(%rip), %rax    # 0x405070
movq %rax, 0xc3b61c(%rip)    # 0xe28500
jmp 0x1ecef4
leaq 0xaa453(%rip), %rax     # 0x297340
movq %rax, 0xc3b60c(%rip)    # 0xe28500
jmp 0x1ecef6
jmp 0x1ecef8
movq 0xc3b601(%rip), %rax    # 0xe28500
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe_stats_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ecf6e
leaq 0x86d87b(%rip), %rax    # 0xa5a7e0
movq %rax, 0xc3b59c(%rip)    # 0xe28508
jmp 0x1ecfb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ecf8a
leaq 0x50336f(%rip), %rax    # 0x6f02f0
movq %rax, 0xc3b580(%rip)    # 0xe28508
jmp 0x1ecfb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ecfa6
leaq 0x221cd3(%rip), %rax    # 0x40ec70
movq %rax, 0xc3b564(%rip)    # 0xe28508
jmp 0x1ecfb4
leaq 0xaa393(%rip), %rax     # 0x297340
movq %rax, 0xc3b554(%rip)    # 0xe28508
jmp 0x1ecfb6
jmp 0x1ecfb8
movq 0xc3b549(%rip), %rax    # 0xe28508
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe_stats_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed02e
leaq 0x87f0cb(%rip), %rax    # 0xa6c0f0
movq %rax, 0xc3b4e4(%rip)    # 0xe28510
jmp 0x1ed078
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed04a
leaq 0x50efff(%rip), %rax    # 0x6fc040
movq %rax, 0xc3b4c8(%rip)    # 0xe28510
jmp 0x1ed076
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed066
leaq 0x22d303(%rip), %rax    # 0x41a360
movq %rax, 0xc3b4ac(%rip)    # 0xe28510
jmp 0x1ed074
leaq 0xaa2d3(%rip), %rax     # 0x297340
movq %rax, 0xc3b49c(%rip)    # 0xe28510
jmp 0x1ed076
jmp 0x1ed078
movq 0xc3b491(%rip), %rax    # 0xe28510
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe_stats_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed0ee
leaq 0x897afb(%rip), %rax    # 0xa84be0
movq %rax, 0xc3b42c(%rip)    # 0xe28518
jmp 0x1ed138
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed10a
leaq 0x51e05f(%rip), %rax    # 0x70b160
movq %rax, 0xc3b410(%rip)    # 0xe28518
jmp 0x1ed136
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed126
leaq 0x23c1d3(%rip), %rax    # 0x4292f0
movq %rax, 0xc3b3f4(%rip)    # 0xe28518
jmp 0x1ed134
leaq 0xaa213(%rip), %rax     # 0x297340
movq %rax, 0xc3b3e4(%rip)    # 0xe28518
jmp 0x1ed136
jmp 0x1ed138
movq 0xc3b3d9(%rip), %rax    # 0xe28518
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed1ae
leaq 0x8d90bb(%rip), %rax    # 0xac6260
movq %rax, 0xc3b374(%rip)    # 0xe28520
jmp 0x1ed1f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed1ca
leaq 0x550d1f(%rip), %rax    # 0x73dee0
movq %rax, 0xc3b358(%rip)    # 0xe28520
jmp 0x1ed1f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed1e6
leaq 0x26cff3(%rip), %rax    # 0x45a1d0
movq %rax, 0xc3b33c(%rip)    # 0xe28520
jmp 0x1ed1f4
leaq 0xac0b3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3b32c(%rip)    # 0xe28520
jmp 0x1ed1f6
jmp 0x1ed1f8
movq 0xc3b321(%rip), %rax    # 0xe28520
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed26e
leaq 0x8dfbcb(%rip), %rax    # 0xacce30
movq %rax, 0xc3b2bc(%rip)    # 0xe28528
jmp 0x1ed2b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed28a
leaq 0x5563af(%rip), %rax    # 0x743630
movq %rax, 0xc3b2a0(%rip)    # 0xe28528
jmp 0x1ed2b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed2a6
leaq 0x272923(%rip), %rax    # 0x45fbc0
movq %rax, 0xc3b284(%rip)    # 0xe28528
jmp 0x1ed2b4
leaq 0xabff3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3b274(%rip)    # 0xe28528
jmp 0x1ed2b6
jmp 0x1ed2b8
movq 0xc3b269(%rip), %rax    # 0xe28528
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed32e
leaq 0x8e78fb(%rip), %rax    # 0xad4c20
movq %rax, 0xc3b204(%rip)    # 0xe28530
jmp 0x1ed378
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed34a
leaq 0x55c0df(%rip), %rax    # 0x749420
movq %rax, 0xc3b1e8(%rip)    # 0xe28530
jmp 0x1ed376
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed366
leaq 0x2787d3(%rip), %rax    # 0x465b30
movq %rax, 0xc3b1cc(%rip)    # 0xe28530
jmp 0x1ed374
leaq 0xabf33(%rip), %rax     # 0x2992a0
movq %rax, 0xc3b1bc(%rip)    # 0xe28530
jmp 0x1ed376
jmp 0x1ed378
movq 0xc3b1b1(%rip), %rax    # 0xe28530
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed3ee
leaq 0x8f182b(%rip), %rax    # 0xadec10
movq %rax, 0xc3b14c(%rip)    # 0xe28538
jmp 0x1ed438
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed40a
leaq 0x56293f(%rip), %rax    # 0x74fd40
movq %rax, 0xc3b130(%rip)    # 0xe28538
jmp 0x1ed436
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed426
leaq 0x27f353(%rip), %rax    # 0x46c770
movq %rax, 0xc3b114(%rip)    # 0xe28538
jmp 0x1ed434
leaq 0xabe73(%rip), %rax     # 0x2992a0
movq %rax, 0xc3b104(%rip)    # 0xe28538
jmp 0x1ed436
jmp 0x1ed438
movq 0xc3b0f9(%rip), %rax    # 0xe28538
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed4ae
leaq 0x92e78b(%rip), %rax    # 0xb1bc30
movq %rax, 0xc3b094(%rip)    # 0xe28540
jmp 0x1ed4f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed4ca
leaq 0x5895cf(%rip), %rax    # 0x776a90
movq %rax, 0xc3b078(%rip)    # 0xe28540
jmp 0x1ed4f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed4e6
leaq 0x2a7123(%rip), %rax    # 0x494600
movq %rax, 0xc3b05c(%rip)    # 0xe28540
jmp 0x1ed4f4
leaq 0xa9e53(%rip), %rax     # 0x297340
movq %rax, 0xc3b04c(%rip)    # 0xe28540
jmp 0x1ed4f6
jmp 0x1ed4f8
movq 0xc3b041(%rip), %rax    # 0xe28540
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed56e
leaq 0x9343eb(%rip), %rax    # 0xb21950
movq %rax, 0xc3afdc(%rip)    # 0xe28548
jmp 0x1ed5b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed58a
leaq 0x58e42f(%rip), %rax    # 0x77b9b0
movq %rax, 0xc3afc0(%rip)    # 0xe28548
jmp 0x1ed5b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed5a6
leaq 0x2ac1c3(%rip), %rax    # 0x499760
movq %rax, 0xc3afa4(%rip)    # 0xe28548
jmp 0x1ed5b4
leaq 0xa9d93(%rip), %rax     # 0x297340
movq %rax, 0xc3af94(%rip)    # 0xe28548
jmp 0x1ed5b6
jmp 0x1ed5b8
movq 0xc3af89(%rip), %rax    # 0xe28548
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed62e
leaq 0x93ad5b(%rip), %rax    # 0xb28380
movq %rax, 0xc3af24(%rip)    # 0xe28550
jmp 0x1ed678
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed64a
leaq 0x59381f(%rip), %rax    # 0x780e60
movq %rax, 0xc3af08(%rip)    # 0xe28550
jmp 0x1ed676
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed666
leaq 0x2b16c3(%rip), %rax    # 0x49ed20
movq %rax, 0xc3aeec(%rip)    # 0xe28550
jmp 0x1ed674
leaq 0xa9cd3(%rip), %rax     # 0x297340
movq %rax, 0xc3aedc(%rip)    # 0xe28550
jmp 0x1ed676
jmp 0x1ed678
movq 0xc3aed1(%rip), %rax    # 0xe28550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed6ee
leaq 0x94318b(%rip), %rax    # 0xb30870
movq %rax, 0xc3ae6c(%rip)    # 0xe28558
jmp 0x1ed738
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed70a
leaq 0x5997bf(%rip), %rax    # 0x786ec0
movq %rax, 0xc3ae50(%rip)    # 0xe28558
jmp 0x1ed736
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed726
leaq 0x2b7973(%rip), %rax    # 0x4a5090
movq %rax, 0xc3ae34(%rip)    # 0xe28558
jmp 0x1ed734
leaq 0xa9c13(%rip), %rax     # 0x297340
movq %rax, 0xc3ae24(%rip)    # 0xe28558
jmp 0x1ed736
jmp 0x1ed738
movq 0xc3ae19(%rip), %rax    # 0xe28558
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed7ae
leaq 0x8fa3ab(%rip), %rax    # 0xae7b50
movq %rax, 0xc3adb4(%rip)    # 0xe28560
jmp 0x1ed7f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed7ca
leaq 0x5688ff(%rip), %rax    # 0x7560c0
movq %rax, 0xc3ad98(%rip)    # 0xe28560
jmp 0x1ed7f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed7e6
leaq 0x2854c3(%rip), %rax    # 0x472ca0
movq %rax, 0xc3ad7c(%rip)    # 0xe28560
jmp 0x1ed7f4
leaq 0xa9b53(%rip), %rax     # 0x297340
movq %rax, 0xc3ad6c(%rip)    # 0xe28560
jmp 0x1ed7f6
jmp 0x1ed7f8
movq 0xc3ad61(%rip), %rax    # 0xe28560
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed86e
leaq 0x90309b(%rip), %rax    # 0xaf0900
movq %rax, 0xc3acfc(%rip)    # 0xe28568
jmp 0x1ed8b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed88a
leaq 0x56eadf(%rip), %rax    # 0x75c360
movq %rax, 0xc3ace0(%rip)    # 0xe28568
jmp 0x1ed8b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed8a6
leaq 0x28b9d3(%rip), %rax    # 0x479270
movq %rax, 0xc3acc4(%rip)    # 0xe28568
jmp 0x1ed8b4
leaq 0xa9a93(%rip), %rax     # 0x297340
movq %rax, 0xc3acb4(%rip)    # 0xe28568
jmp 0x1ed8b6
jmp 0x1ed8b8
movq 0xc3aca9(%rip), %rax    # 0xe28568
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed92e
leaq 0x90f90b(%rip), %rax    # 0xafd230
movq %rax, 0xc3ac44(%rip)    # 0xe28570
jmp 0x1ed978
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ed94a
leaq 0x5767ff(%rip), %rax    # 0x764140
movq %rax, 0xc3ac28(%rip)    # 0xe28570
jmp 0x1ed976
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ed966
leaq 0x293963(%rip), %rax    # 0x4812c0
movq %rax, 0xc3ac0c(%rip)    # 0xe28570
jmp 0x1ed974
leaq 0xa99d3(%rip), %rax     # 0x297340
movq %rax, 0xc3abfc(%rip)    # 0xe28570
jmp 0x1ed976
jmp 0x1ed978
movq 0xc3abf1(%rip), %rax    # 0xe28570
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_rowcol_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ed9ee
leaq 0x92335b(%rip), %rax    # 0xb10d40
movq %rax, 0xc3ab8c(%rip)    # 0xe28578
jmp 0x1eda38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eda0a
leaq 0x58199f(%rip), %rax    # 0x76f3a0
movq %rax, 0xc3ab70(%rip)    # 0xe28578
jmp 0x1eda36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eda26
leaq 0x29f1a3(%rip), %rax    # 0x48cbc0
movq %rax, 0xc3ab54(%rip)    # 0xe28578
jmp 0x1eda34
leaq 0xa9913(%rip), %rax     # 0x297340
movq %rax, 0xc3ab44(%rip)    # 0xe28578
jmp 0x1eda36
jmp 0x1eda38
movq 0xc3ab39(%rip), %rax    # 0xe28578
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_rowcol_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1edaae
leaq 0x94f04b(%rip), %rax    # 0xb3caf0
movq %rax, 0xc3aad4(%rip)    # 0xe28580
jmp 0x1edaf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1edaca
leaq 0x5a4a3f(%rip), %rax    # 0x792500
movq %rax, 0xc3aab8(%rip)    # 0xe28580
jmp 0x1edaf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1edae6
leaq 0x2c0943(%rip), %rax    # 0x4ae420
movq %rax, 0xc3aa9c(%rip)    # 0xe28580
jmp 0x1edaf4
leaq 0xab7b3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3aa8c(%rip)    # 0xe28580
jmp 0x1edaf6
jmp 0x1edaf8
movq 0xc3aa81(%rip), %rax    # 0xe28580
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)