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_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_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 0x1ebeee
leaq 0x76eb6b(%rip), %rax    # 0x95aa50
movq %rax, 0xc3c56c(%rip)    # 0xe28458
jmp 0x1ebf38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ebf0a
leaq 0x449a9f(%rip), %rax    # 0x6359a0
movq %rax, 0xc3c550(%rip)    # 0xe28458
jmp 0x1ebf36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebf26
leaq 0x16b743(%rip), %rax    # 0x357660
movq %rax, 0xc3c534(%rip)    # 0xe28458
jmp 0x1ebf34
leaq 0xab413(%rip), %rax     # 0x297340
movq %rax, 0xc3c524(%rip)    # 0xe28458
jmp 0x1ebf36
jmp 0x1ebf38
movq 0xc3c519(%rip), %rax    # 0xe28458
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_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x1ebfae
leaq 0x7ad9db(%rip), %rax    # 0x999980
movq %rax, 0xc3c4b4(%rip)    # 0xe28460
jmp 0x1ebff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ebfca
leaq 0x47991f(%rip), %rax    # 0x6658e0
movq %rax, 0xc3c498(%rip)    # 0xe28460
jmp 0x1ebff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ebfe6
leaq 0x19b933(%rip), %rax    # 0x387910
movq %rax, 0xc3c47c(%rip)    # 0xe28460
jmp 0x1ebff4
leaq 0xad2b3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3c46c(%rip)    # 0xe28460
jmp 0x1ebff6
jmp 0x1ebff8
movq 0xc3c461(%rip), %rax    # 0xe28460
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_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x1ec06e
leaq 0x7b433b(%rip), %rax    # 0x9a03a0
movq %rax, 0xc3c3fc(%rip)    # 0xe28468
jmp 0x1ec0b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec08a
leaq 0x47edaf(%rip), %rax    # 0x66ae30
movq %rax, 0xc3c3e0(%rip)    # 0xe28468
jmp 0x1ec0b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec0a6
leaq 0x1a1063(%rip), %rax    # 0x38d100
movq %rax, 0xc3c3c4(%rip)    # 0xe28468
jmp 0x1ec0b4
leaq 0xad1f3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3c3b4(%rip)    # 0xe28468
jmp 0x1ec0b6
jmp 0x1ec0b8
movq 0xc3c3a9(%rip), %rax    # 0xe28468
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_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x1ec12e
leaq 0x7bbffb(%rip), %rax    # 0x9a8120
movq %rax, 0xc3c344(%rip)    # 0xe28470
jmp 0x1ec178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec14a
leaq 0x48495f(%rip), %rax    # 0x670aa0
movq %rax, 0xc3c328(%rip)    # 0xe28470
jmp 0x1ec176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec166
leaq 0x1a6da3(%rip), %rax    # 0x392f00
movq %rax, 0xc3c30c(%rip)    # 0xe28470
jmp 0x1ec174
leaq 0xad133(%rip), %rax     # 0x2992a0
movq %rax, 0xc3c2fc(%rip)    # 0xe28470
jmp 0x1ec176
jmp 0x1ec178
movq 0xc3c2f1(%rip), %rax    # 0xe28470
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_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_table_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 0x1ec1ee
leaq 0x7c616b(%rip), %rax    # 0x9b2350
movq %rax, 0xc3c28c(%rip)    # 0xe28478
jmp 0x1ec238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec20a
leaq 0x48b16f(%rip), %rax    # 0x677370
movq %rax, 0xc3c270(%rip)    # 0xe28478
jmp 0x1ec236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec226
leaq 0x1ad933(%rip), %rax    # 0x399b50
movq %rax, 0xc3c254(%rip)    # 0xe28478
jmp 0x1ec234
leaq 0xad073(%rip), %rax     # 0x2992a0
movq %rax, 0xc3c244(%rip)    # 0xe28478
jmp 0x1ec236
jmp 0x1ec238
movq 0xc3c239(%rip), %rax    # 0xe28478
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_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x1ec2ae
leaq 0x80122b(%rip), %rax    # 0x9ed4d0
movq %rax, 0xc3c1d4(%rip)    # 0xe28480
jmp 0x1ec2f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec2ca
leaq 0x4b0f3f(%rip), %rax    # 0x69d200
movq %rax, 0xc3c1b8(%rip)    # 0xe28480
jmp 0x1ec2f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec2e6
leaq 0x1d4713(%rip), %rax    # 0x3c09f0
movq %rax, 0xc3c19c(%rip)    # 0xe28480
jmp 0x1ec2f4
leaq 0xab053(%rip), %rax     # 0x297340
movq %rax, 0xc3c18c(%rip)    # 0xe28480
jmp 0x1ec2f6
jmp 0x1ec2f8
movq 0xc3c181(%rip), %rax    # 0xe28480
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_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_table_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 0x1ec36e
leaq 0x806d7b(%rip), %rax    # 0x9f30e0
movq %rax, 0xc3c11c(%rip)    # 0xe28488
jmp 0x1ec3b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec38a
leaq 0x4b5c3f(%rip), %rax    # 0x6a1fc0
movq %rax, 0xc3c100(%rip)    # 0xe28488
jmp 0x1ec3b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec3a6
leaq 0x1d9653(%rip), %rax    # 0x3c59f0
movq %rax, 0xc3c0e4(%rip)    # 0xe28488
jmp 0x1ec3b4
leaq 0xaaf93(%rip), %rax     # 0x297340
movq %rax, 0xc3c0d4(%rip)    # 0xe28488
jmp 0x1ec3b6
jmp 0x1ec3b8
movq 0xc3c0c9(%rip), %rax    # 0xe28488
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_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_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_table_striped_16_pointer = parasail_sg_qe_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x1ec42e
leaq 0x80d72b(%rip), %rax    # 0x9f9b50
movq %rax, 0xc3c064(%rip)    # 0xe28490
jmp 0x1ec478
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec44a
leaq 0x4baf4f(%rip), %rax    # 0x6a7390
movq %rax, 0xc3c048(%rip)    # 0xe28490
jmp 0x1ec476
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec466
leaq 0x1dea73(%rip), %rax    # 0x3caed0
movq %rax, 0xc3c02c(%rip)    # 0xe28490
jmp 0x1ec474
leaq 0xaaed3(%rip), %rax     # 0x297340
movq %rax, 0xc3c01c(%rip)    # 0xe28490
jmp 0x1ec476
jmp 0x1ec478
movq 0xc3c011(%rip), %rax    # 0xe28490
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_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_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_table_striped_8_pointer = parasail_sg_qe_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x1ec4ee
leaq 0x815e2b(%rip), %rax    # 0xa02310
movq %rax, 0xc3bfac(%rip)    # 0xe28498
jmp 0x1ec538
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec50a
leaq 0x4c0f5f(%rip), %rax    # 0x6ad460
movq %rax, 0xc3bf90(%rip)    # 0xe28498
jmp 0x1ec536
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec526
leaq 0x1e4df3(%rip), %rax    # 0x3d1310
movq %rax, 0xc3bf74(%rip)    # 0xe28498
jmp 0x1ec534
leaq 0xaae13(%rip), %rax     # 0x297340
movq %rax, 0xc3bf64(%rip)    # 0xe28498
jmp 0x1ec536
jmp 0x1ec538
movq 0xc3bf59(%rip), %rax    # 0xe28498
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_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_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_table_diag_64_pointer = parasail_sg_qe_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x1ec5ae
leaq 0x7cec8b(%rip), %rax    # 0x9bb230
movq %rax, 0xc3bef4(%rip)    # 0xe284a0
jmp 0x1ec5f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec5ca
leaq 0x49105f(%rip), %rax    # 0x67d620
movq %rax, 0xc3bed8(%rip)    # 0xe284a0
jmp 0x1ec5f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec5e6
leaq 0x1b39c3(%rip), %rax    # 0x39ffa0
movq %rax, 0xc3bebc(%rip)    # 0xe284a0
jmp 0x1ec5f4
leaq 0xaad53(%rip), %rax     # 0x297340
movq %rax, 0xc3beac(%rip)    # 0xe284a0
jmp 0x1ec5f6
jmp 0x1ec5f8
movq 0xc3bea1(%rip), %rax    # 0xe284a0
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_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_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_table_diag_32_pointer = parasail_sg_qe_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x1ec66e
leaq 0x7d76ab(%rip), %rax    # 0x9c3d10
movq %rax, 0xc3be3c(%rip)    # 0xe284a8
jmp 0x1ec6b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec68a
leaq 0x4970ef(%rip), %rax    # 0x683770
movq %rax, 0xc3be20(%rip)    # 0xe284a8
jmp 0x1ec6b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec6a6
leaq 0x1b9d03(%rip), %rax    # 0x3a63a0
movq %rax, 0xc3be04(%rip)    # 0xe284a8
jmp 0x1ec6b4
leaq 0xaac93(%rip), %rax     # 0x297340
movq %rax, 0xc3bdf4(%rip)    # 0xe284a8
jmp 0x1ec6b6
jmp 0x1ec6b8
movq 0xc3bde9(%rip), %rax    # 0xe284a8
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_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_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_table_diag_16_pointer = parasail_sg_qe_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x1ec72e
leaq 0x7e388b(%rip), %rax    # 0x9cffb0
movq %rax, 0xc3bd84(%rip)    # 0xe284b0
jmp 0x1ec778
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec74a
leaq 0x49eb0f(%rip), %rax    # 0x68b250
movq %rax, 0xc3bd68(%rip)    # 0xe284b0
jmp 0x1ec776
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec766
leaq 0x1c1943(%rip), %rax    # 0x3ae0a0
movq %rax, 0xc3bd4c(%rip)    # 0xe284b0
jmp 0x1ec774
leaq 0xaabd3(%rip), %rax     # 0x297340
movq %rax, 0xc3bd3c(%rip)    # 0xe284b0
jmp 0x1ec776
jmp 0x1ec778
movq 0xc3bd31(%rip), %rax    # 0xe284b0
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_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_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_table_diag_8_pointer = parasail_sg_qe_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_table_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_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 0x1ec7ee
leaq 0x7f648b(%rip), %rax    # 0x9e2c70
movq %rax, 0xc3bccc(%rip)    # 0xe284b8
jmp 0x1ec838
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec80a
leaq 0x4a965f(%rip), %rax    # 0x695e60
movq %rax, 0xc3bcb0(%rip)    # 0xe284b8
jmp 0x1ec836
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec826
leaq 0x1ccb03(%rip), %rax    # 0x3b9320
movq %rax, 0xc3bc94(%rip)    # 0xe284b8
jmp 0x1ec834
leaq 0xaab13(%rip), %rax     # 0x297340
movq %rax, 0xc3bc84(%rip)    # 0xe284b8
jmp 0x1ec836
jmp 0x1ec838
movq 0xc3bc79(%rip), %rax    # 0xe284b8
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_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x1ec8ae
leaq 0x82199b(%rip), %rax    # 0xa0e240
movq %rax, 0xc3bc14(%rip)    # 0xe284c0
jmp 0x1ec8f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec8ca
leaq 0x4cbcaf(%rip), %rax    # 0x6b8570
movq %rax, 0xc3bbf8(%rip)    # 0xe284c0
jmp 0x1ec8f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec8e6
leaq 0x1ed9b3(%rip), %rax    # 0x3da290
movq %rax, 0xc3bbdc(%rip)    # 0xe284c0
jmp 0x1ec8f4
leaq 0xac9b3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3bbcc(%rip)    # 0xe284c0
jmp 0x1ec8f6
jmp 0x1ec8f8
movq 0xc3bbc1(%rip), %rax    # 0xe284c0
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_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x1ec96e
leaq 0x82f30b(%rip), %rax    # 0xa1bc70
movq %rax, 0xc3bb5c(%rip)    # 0xe284c8
jmp 0x1ec9b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ec98a
leaq 0x4d6b2f(%rip), %rax    # 0x6c34b0
movq %rax, 0xc3bb40(%rip)    # 0xe284c8
jmp 0x1ec9b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ec9a6
leaq 0x1f7b83(%rip), %rax    # 0x3e4520
movq %rax, 0xc3bb24(%rip)    # 0xe284c8
jmp 0x1ec9b4
leaq 0xac8f3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3bb14(%rip)    # 0xe284c8
jmp 0x1ec9b6
jmp 0x1ec9b8
movq 0xc3bb09(%rip), %rax    # 0xe284c8
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_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x1eca2e
leaq 0x83e73b(%rip), %rax    # 0xa2b160
movq %rax, 0xc3baa4(%rip)    # 0xe284d0
jmp 0x1eca78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eca4a
leaq 0x4e228f(%rip), %rax    # 0x6cecd0
movq %rax, 0xc3ba88(%rip)    # 0xe284d0
jmp 0x1eca76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1eca66
leaq 0x202563(%rip), %rax    # 0x3eefc0
movq %rax, 0xc3ba6c(%rip)    # 0xe284d0
jmp 0x1eca74
leaq 0xac833(%rip), %rax     # 0x2992a0
movq %rax, 0xc3ba5c(%rip)    # 0xe284d0
jmp 0x1eca76
jmp 0x1eca78
movq 0xc3ba51(%rip), %rax    # 0xe284d0
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_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_table_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 0x1ecaee
leaq 0x850d0b(%rip), %rax    # 0xa3d7f0
movq %rax, 0xc3b9ec(%rip)    # 0xe284d8
jmp 0x1ecb38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ecb0a
leaq 0x4ee92f(%rip), %rax    # 0x6db430
movq %rax, 0xc3b9d0(%rip)    # 0xe284d8
jmp 0x1ecb36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ecb26
leaq 0x20e0a3(%rip), %rax    # 0x3fabc0
movq %rax, 0xc3b9b4(%rip)    # 0xe284d8
jmp 0x1ecb34
leaq 0xac773(%rip), %rax     # 0x2992a0
movq %rax, 0xc3b9a4(%rip)    # 0xe284d8
jmp 0x1ecb36
jmp 0x1ecb38
movq 0xc3b999(%rip), %rax    # 0xe284d8
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_64_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_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 0x1ecbae
leaq 0x8a85fb(%rip), %rax    # 0xa951a0
movq %rax, 0xc3b934(%rip)    # 0xe284e0
jmp 0x1ecbf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ecbca
leaq 0x52a3cf(%rip), %rax    # 0x716f90
movq %rax, 0xc3b918(%rip)    # 0xe284e0
jmp 0x1ecbf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ecbe6
leaq 0x247fe3(%rip), %rax    # 0x434bc0
movq %rax, 0xc3b8fc(%rip)    # 0xe284e0
jmp 0x1ecbf4
leaq 0xaa753(%rip), %rax     # 0x297340
movq %rax, 0xc3b8ec(%rip)    # 0xe284e0
jmp 0x1ecbf6
jmp 0x1ecbf8
movq 0xc3b8e1(%rip), %rax    # 0xe284e0
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_32_dispatcher
parasail_result_t* parasail_sg_qe_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_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_table_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_table_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 0x1ecc6e
leaq 0x8b3e5b(%rip), %rax    # 0xaa0ac0
movq %rax, 0xc3b87c(%rip)    # 0xe284e8
jmp 0x1eccb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ecc8a
leaq 0x533e1f(%rip), %rax    # 0x720aa0
movq %rax, 0xc3b860(%rip)    # 0xe284e8
jmp 0x1eccb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ecca6
leaq 0x251403(%rip), %rax    # 0x43e0a0
movq %rax, 0xc3b844(%rip)    # 0xe284e8
jmp 0x1eccb4
leaq 0xaa693(%rip), %rax     # 0x297340
movq %rax, 0xc3b834(%rip)    # 0xe284e8
jmp 0x1eccb6
jmp 0x1eccb8
movq 0xc3b829(%rip), %rax    # 0xe284e8
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)