LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e336e
leaq 0x7c4d4b(%rip), %rax    # 0x9a80b0
movq %rax, 0xc44ca4(%rip)    # 0xe28010
jmp 0x1e33b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e338a
leaq 0x48d6af(%rip), %rax    # 0x670a30
movq %rax, 0xc44c88(%rip)    # 0xe28010
jmp 0x1e33b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e33a6
leaq 0x1afaf3(%rip), %rax    # 0x392e90
movq %rax, 0xc44c6c(%rip)    # 0xe28010
jmp 0x1e33b4
leaq 0xb5e83(%rip), %rax     # 0x299230
movq %rax, 0xc44c5c(%rip)    # 0xe28010
jmp 0x1e33b6
jmp 0x1e33b8
movq 0xc44c51(%rip), %rax    # 0xe28010
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_qb_dispatch.c
// Function: parasail_sg_qb_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e342e
leaq 0x7ceebb(%rip), %rax    # 0x9b22e0
movq %rax, 0xc44bec(%rip)    # 0xe28018
jmp 0x1e3478
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e344a
leaq 0x493ebf(%rip), %rax    # 0x677300
movq %rax, 0xc44bd0(%rip)    # 0xe28018
jmp 0x1e3476
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3466
leaq 0x1b6683(%rip), %rax    # 0x399ae0
movq %rax, 0xc44bb4(%rip)    # 0xe28018
jmp 0x1e3474
leaq 0xb5dc3(%rip), %rax     # 0x299230
movq %rax, 0xc44ba4(%rip)    # 0xe28018
jmp 0x1e3476
jmp 0x1e3478
movq 0xc44b99(%rip), %rax    # 0xe28018
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e34ee
leaq 0x809f7b(%rip), %rax    # 0x9ed460
movq %rax, 0xc44b34(%rip)    # 0xe28020
jmp 0x1e3538
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e350a
leaq 0x4b9c8f(%rip), %rax    # 0x69d190
movq %rax, 0xc44b18(%rip)    # 0xe28020
jmp 0x1e3536
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3526
leaq 0x1dd463(%rip), %rax    # 0x3c0980
movq %rax, 0xc44afc(%rip)    # 0xe28020
jmp 0x1e3534
leaq 0xb3da3(%rip), %rax     # 0x2972d0
movq %rax, 0xc44aec(%rip)    # 0xe28020
jmp 0x1e3536
jmp 0x1e3538
movq 0xc44ae1(%rip), %rax    # 0xe28020
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e35ae
leaq 0x80facb(%rip), %rax    # 0x9f3070
movq %rax, 0xc44a7c(%rip)    # 0xe28028
jmp 0x1e35f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e35ca
leaq 0x4be98f(%rip), %rax    # 0x6a1f50
movq %rax, 0xc44a60(%rip)    # 0xe28028
jmp 0x1e35f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e35e6
leaq 0x1e23a3(%rip), %rax    # 0x3c5980
movq %rax, 0xc44a44(%rip)    # 0xe28028
jmp 0x1e35f4
leaq 0xb3ce3(%rip), %rax     # 0x2972d0
movq %rax, 0xc44a34(%rip)    # 0xe28028
jmp 0x1e35f6
jmp 0x1e35f8
movq 0xc44a29(%rip), %rax    # 0xe28028
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e366e
leaq 0x81647b(%rip), %rax    # 0x9f9ae0
movq %rax, 0xc449c4(%rip)    # 0xe28030
jmp 0x1e36b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e368a
leaq 0x4c3c9f(%rip), %rax    # 0x6a7320
movq %rax, 0xc449a8(%rip)    # 0xe28030
jmp 0x1e36b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e36a6
leaq 0x1e77c3(%rip), %rax    # 0x3cae60
movq %rax, 0xc4498c(%rip)    # 0xe28030
jmp 0x1e36b4
leaq 0xb3c23(%rip), %rax     # 0x2972d0
movq %rax, 0xc4497c(%rip)    # 0xe28030
jmp 0x1e36b6
jmp 0x1e36b8
movq 0xc44971(%rip), %rax    # 0xe28030
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_qb_dispatch.c
// Function: parasail_sg_qb_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e372e
leaq 0x81eb7b(%rip), %rax    # 0xa022a0
movq %rax, 0xc4490c(%rip)    # 0xe28038
jmp 0x1e3778
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e374a
leaq 0x4c9caf(%rip), %rax    # 0x6ad3f0
movq %rax, 0xc448f0(%rip)    # 0xe28038
jmp 0x1e3776
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3766
leaq 0x1edb43(%rip), %rax    # 0x3d12a0
movq %rax, 0xc448d4(%rip)    # 0xe28038
jmp 0x1e3774
leaq 0xb3b63(%rip), %rax     # 0x2972d0
movq %rax, 0xc448c4(%rip)    # 0xe28038
jmp 0x1e3776
jmp 0x1e3778
movq 0xc448b9(%rip), %rax    # 0xe28038
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_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e37ee
leaq 0x7d79db(%rip), %rax    # 0x9bb1c0
movq %rax, 0xc44854(%rip)    # 0xe28040
jmp 0x1e3838
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e380a
leaq 0x499daf(%rip), %rax    # 0x67d5b0
movq %rax, 0xc44838(%rip)    # 0xe28040
jmp 0x1e3836
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3826
leaq 0x1bc713(%rip), %rax    # 0x39ff30
movq %rax, 0xc4481c(%rip)    # 0xe28040
jmp 0x1e3834
leaq 0xb3aa3(%rip), %rax     # 0x2972d0
movq %rax, 0xc4480c(%rip)    # 0xe28040
jmp 0x1e3836
jmp 0x1e3838
movq 0xc44801(%rip), %rax    # 0xe28040
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_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e38ae
leaq 0x7e03fb(%rip), %rax    # 0x9c3ca0
movq %rax, 0xc4479c(%rip)    # 0xe28048
jmp 0x1e38f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e38ca
leaq 0x49fe3f(%rip), %rax    # 0x683700
movq %rax, 0xc44780(%rip)    # 0xe28048
jmp 0x1e38f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e38e6
leaq 0x1c2a53(%rip), %rax    # 0x3a6330
movq %rax, 0xc44764(%rip)    # 0xe28048
jmp 0x1e38f4
leaq 0xb39e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc44754(%rip)    # 0xe28048
jmp 0x1e38f6
jmp 0x1e38f8
movq 0xc44749(%rip), %rax    # 0xe28048
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_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e396e
leaq 0x7ec5db(%rip), %rax    # 0x9cff40
movq %rax, 0xc446e4(%rip)    # 0xe28050
jmp 0x1e39b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e398a
leaq 0x4a785f(%rip), %rax    # 0x68b1e0
movq %rax, 0xc446c8(%rip)    # 0xe28050
jmp 0x1e39b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e39a6
leaq 0x1ca693(%rip), %rax    # 0x3ae030
movq %rax, 0xc446ac(%rip)    # 0xe28050
jmp 0x1e39b4
leaq 0xb3923(%rip), %rax     # 0x2972d0
movq %rax, 0xc4469c(%rip)    # 0xe28050
jmp 0x1e39b6
jmp 0x1e39b8
movq 0xc44691(%rip), %rax    # 0xe28050
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_qb_dispatch.c
// Function: parasail_sg_qb_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_table_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e3a2e
leaq 0x7ff1db(%rip), %rax    # 0x9e2c00
movq %rax, 0xc4462c(%rip)    # 0xe28058
jmp 0x1e3a78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3a4a
leaq 0x4b23af(%rip), %rax    # 0x695df0
movq %rax, 0xc44610(%rip)    # 0xe28058
jmp 0x1e3a76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3a66
leaq 0x1d5853(%rip), %rax    # 0x3b92b0
movq %rax, 0xc445f4(%rip)    # 0xe28058
jmp 0x1e3a74
leaq 0xb3863(%rip), %rax     # 0x2972d0
movq %rax, 0xc445e4(%rip)    # 0xe28058
jmp 0x1e3a76
jmp 0x1e3a78
movq 0xc445d9(%rip), %rax    # 0xe28058
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e3aee
leaq 0x82a6eb(%rip), %rax    # 0xa0e1d0
movq %rax, 0xc44574(%rip)    # 0xe28060
jmp 0x1e3b38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3b0a
leaq 0x4d49ff(%rip), %rax    # 0x6b8500
movq %rax, 0xc44558(%rip)    # 0xe28060
jmp 0x1e3b36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3b26
leaq 0x1f6703(%rip), %rax    # 0x3da220
movq %rax, 0xc4453c(%rip)    # 0xe28060
jmp 0x1e3b34
leaq 0xb5703(%rip), %rax     # 0x299230
movq %rax, 0xc4452c(%rip)    # 0xe28060
jmp 0x1e3b36
jmp 0x1e3b38
movq 0xc44521(%rip), %rax    # 0xe28060
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e3bae
leaq 0x83805b(%rip), %rax    # 0xa1bc00
movq %rax, 0xc444bc(%rip)    # 0xe28068
jmp 0x1e3bf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3bca
leaq 0x4df87f(%rip), %rax    # 0x6c3440
movq %rax, 0xc444a0(%rip)    # 0xe28068
jmp 0x1e3bf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3be6
leaq 0x2008d3(%rip), %rax    # 0x3e44b0
movq %rax, 0xc44484(%rip)    # 0xe28068
jmp 0x1e3bf4
leaq 0xb5643(%rip), %rax     # 0x299230
movq %rax, 0xc44474(%rip)    # 0xe28068
jmp 0x1e3bf6
jmp 0x1e3bf8
movq 0xc44469(%rip), %rax    # 0xe28068
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e3c6e
leaq 0x84748b(%rip), %rax    # 0xa2b0f0
movq %rax, 0xc44404(%rip)    # 0xe28070
jmp 0x1e3cb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3c8a
leaq 0x4eafdf(%rip), %rax    # 0x6cec60
movq %rax, 0xc443e8(%rip)    # 0xe28070
jmp 0x1e3cb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3ca6
leaq 0x20b2b3(%rip), %rax    # 0x3eef50
movq %rax, 0xc443cc(%rip)    # 0xe28070
jmp 0x1e3cb4
leaq 0xb5583(%rip), %rax     # 0x299230
movq %rax, 0xc443bc(%rip)    # 0xe28070
jmp 0x1e3cb6
jmp 0x1e3cb8
movq 0xc443b1(%rip), %rax    # 0xe28070
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_stats_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e3d2e
leaq 0x859a5b(%rip), %rax    # 0xa3d780
movq %rax, 0xc4434c(%rip)    # 0xe28078
jmp 0x1e3d78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3d4a
leaq 0x4f767f(%rip), %rax    # 0x6db3c0
movq %rax, 0xc44330(%rip)    # 0xe28078
jmp 0x1e3d76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3d66
leaq 0x216df3(%rip), %rax    # 0x3fab50
movq %rax, 0xc44314(%rip)    # 0xe28078
jmp 0x1e3d74
leaq 0xb54c3(%rip), %rax     # 0x299230
movq %rax, 0xc44304(%rip)    # 0xe28078
jmp 0x1e3d76
jmp 0x1e3d78
movq 0xc442f9(%rip), %rax    # 0xe28078
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb_stats_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e3dee
leaq 0x8b134b(%rip), %rax    # 0xa95130
movq %rax, 0xc44294(%rip)    # 0xe28080
jmp 0x1e3e38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3e0a
leaq 0x53311f(%rip), %rax    # 0x716f20
movq %rax, 0xc44278(%rip)    # 0xe28080
jmp 0x1e3e36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3e26
leaq 0x250d33(%rip), %rax    # 0x434b50
movq %rax, 0xc4425c(%rip)    # 0xe28080
jmp 0x1e3e34
leaq 0xb34a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc4424c(%rip)    # 0xe28080
jmp 0x1e3e36
jmp 0x1e3e38
movq 0xc44241(%rip), %rax    # 0xe28080
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb_stats_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e3eae
leaq 0x8bcbab(%rip), %rax    # 0xaa0a50
movq %rax, 0xc441dc(%rip)    # 0xe28088
jmp 0x1e3ef8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3eca
leaq 0x53cb6f(%rip), %rax    # 0x720a30
movq %rax, 0xc441c0(%rip)    # 0xe28088
jmp 0x1e3ef6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3ee6
leaq 0x25a153(%rip), %rax    # 0x43e030
movq %rax, 0xc441a4(%rip)    # 0xe28088
jmp 0x1e3ef4
leaq 0xb33e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc44194(%rip)    # 0xe28088
jmp 0x1e3ef6
jmp 0x1e3ef8
movq 0xc44189(%rip), %rax    # 0xe28088
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb_stats_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e3f6e
leaq 0x8c958b(%rip), %rax    # 0xaad4f0
movq %rax, 0xc44124(%rip)    # 0xe28090
jmp 0x1e3fb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e3f8a
leaq 0x546d9f(%rip), %rax    # 0x72ad20
movq %rax, 0xc44108(%rip)    # 0xe28090
jmp 0x1e3fb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3fa6
leaq 0x263b63(%rip), %rax    # 0x447b00
movq %rax, 0xc440ec(%rip)    # 0xe28090
jmp 0x1e3fb4
leaq 0xb3323(%rip), %rax     # 0x2972d0
movq %rax, 0xc440dc(%rip)    # 0xe28090
jmp 0x1e3fb6
jmp 0x1e3fb8
movq 0xc440d1(%rip), %rax    # 0xe28090
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb_stats_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e402e
leaq 0x8d830b(%rip), %rax    # 0xabc330
movq %rax, 0xc4406c(%rip)    # 0xe28098
jmp 0x1e4078
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e404a
leaq 0x55214f(%rip), %rax    # 0x736190
movq %rax, 0xc44050(%rip)    # 0xe28098
jmp 0x1e4076
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4066
leaq 0x26e753(%rip), %rax    # 0x4527b0
movq %rax, 0xc44034(%rip)    # 0xe28098
jmp 0x1e4074
leaq 0xb3263(%rip), %rax     # 0x2972d0
movq %rax, 0xc44024(%rip)    # 0xe28098
jmp 0x1e4076
jmp 0x1e4078
movq 0xc44019(%rip), %rax    # 0xe28098
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_qb_dispatch.c
// Function: parasail_sg_qb_stats_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb_stats_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_table_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e40ee
leaq 0x8689bb(%rip), %rax    # 0xa4caa0
movq %rax, 0xc43fb4(%rip)    # 0xe280a0
jmp 0x1e4138
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e410a
leaq 0x50200f(%rip), %rax    # 0x6e6110
movq %rax, 0xc43f98(%rip)    # 0xe280a0
jmp 0x1e4136
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e4126
leaq 0x220ee3(%rip), %rax    # 0x405000
movq %rax, 0xc43f7c(%rip)    # 0xe280a0
jmp 0x1e4134
leaq 0xb31a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc43f6c(%rip)    # 0xe280a0
jmp 0x1e4136
jmp 0x1e4138
movq 0xc43f61(%rip), %rax    # 0xe280a0
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)