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_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_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_striped_16_pointer = parasail_sg_qb_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e246e
leaq 0x6f794b(%rip), %rax    # 0x8d9db0
movq %rax, 0xc45b04(%rip)    # 0xe27f70
jmp 0x1e24b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e248a
leaq 0x3f4f6f(%rip), %rax    # 0x5d73f0
movq %rax, 0xc45ae8(%rip)    # 0xe27f70
jmp 0x1e24b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e24a6
leaq 0x11c6a3(%rip), %rax    # 0x2feb40
movq %rax, 0xc45acc(%rip)    # 0xe27f70
jmp 0x1e24b4
leaq 0xb4e23(%rip), %rax     # 0x2972d0
movq %rax, 0xc45abc(%rip)    # 0xe27f70
jmp 0x1e24b6
jmp 0x1e24b8
movq 0xc45ab1(%rip), %rax    # 0xe27f70
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_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_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_striped_8_pointer = parasail_sg_qb_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e252e
leaq 0x6feacb(%rip), %rax    # 0x8e0ff0
movq %rax, 0xc45a4c(%rip)    # 0xe27f78
jmp 0x1e2578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e254a
leaq 0x3fa54f(%rip), %rax    # 0x5dca90
movq %rax, 0xc45a30(%rip)    # 0xe27f78
jmp 0x1e2576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2566
leaq 0x121f83(%rip), %rax    # 0x3044e0
movq %rax, 0xc45a14(%rip)    # 0xe27f78
jmp 0x1e2574
leaq 0xb4d63(%rip), %rax     # 0x2972d0
movq %rax, 0xc45a04(%rip)    # 0xe27f78
jmp 0x1e2576
jmp 0x1e2578
movq 0xc459f9(%rip), %rax    # 0xe27f78
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_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_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_diag_64_pointer = parasail_sg_qb_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e25ee
leaq 0x6bf2ab(%rip), %rax    # 0x8a1890
movq %rax, 0xc45994(%rip)    # 0xe27f80
jmp 0x1e2638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e260a
leaq 0x3ce11f(%rip), %rax    # 0x5b0720
movq %rax, 0xc45978(%rip)    # 0xe27f80
jmp 0x1e2636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2626
leaq 0xf4943(%rip), %rax     # 0x2d6f60
movq %rax, 0xc4595c(%rip)    # 0xe27f80
jmp 0x1e2634
leaq 0xb4ca3(%rip), %rax     # 0x2972d0
movq %rax, 0xc4594c(%rip)    # 0xe27f80
jmp 0x1e2636
jmp 0x1e2638
movq 0xc45941(%rip), %rax    # 0xe27f80
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_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_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_diag_32_pointer = parasail_sg_qb_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e26ae
leaq 0x6c735b(%rip), %rax    # 0x8a9a00
movq %rax, 0xc458dc(%rip)    # 0xe27f88
jmp 0x1e26f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e26ca
leaq 0x3d3cdf(%rip), %rax    # 0x5b63a0
movq %rax, 0xc458c0(%rip)    # 0xe27f88
jmp 0x1e26f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e26e6
leaq 0xfa723(%rip), %rax     # 0x2dce00
movq %rax, 0xc458a4(%rip)    # 0xe27f88
jmp 0x1e26f4
leaq 0xb4be3(%rip), %rax     # 0x2972d0
movq %rax, 0xc45894(%rip)    # 0xe27f88
jmp 0x1e26f6
jmp 0x1e26f8
movq 0xc45889(%rip), %rax    # 0xe27f88
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_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_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_diag_16_pointer = parasail_sg_qb_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e276e
leaq 0x6d224b(%rip), %rax    # 0x8b49b0
movq %rax, 0xc45824(%rip)    # 0xe27f90
jmp 0x1e27b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e278a
leaq 0x3dae0f(%rip), %rax    # 0x5bd590
movq %rax, 0xc45808(%rip)    # 0xe27f90
jmp 0x1e27b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e27a6
leaq 0x101a33(%rip), %rax    # 0x2e41d0
movq %rax, 0xc457ec(%rip)    # 0xe27f90
jmp 0x1e27b4
leaq 0xb4b23(%rip), %rax     # 0x2972d0
movq %rax, 0xc457dc(%rip)    # 0xe27f90
jmp 0x1e27b6
jmp 0x1e27b8
movq 0xc457d1(%rip), %rax    # 0xe27f90
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_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_diag_8_pointer = parasail_sg_qb_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e282e
leaq 0x6e293b(%rip), %rax    # 0x8c5160
movq %rax, 0xc4576c(%rip)    # 0xe27f98
jmp 0x1e2878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e284a
leaq 0x3e482f(%rip), %rax    # 0x5c7070
movq %rax, 0xc45750(%rip)    # 0xe27f98
jmp 0x1e2876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2866
leaq 0x10ba63(%rip), %rax    # 0x2ee2c0
movq %rax, 0xc45734(%rip)    # 0xe27f98
jmp 0x1e2874
leaq 0xb4a63(%rip), %rax     # 0x2972d0
movq %rax, 0xc45724(%rip)    # 0xe27f98
jmp 0x1e2876
jmp 0x1e2878
movq 0xc45719(%rip), %rax    # 0xe27f98
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_scan_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_scan_64_pointer = parasail_sg_qb_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_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 0x1e28ee
leaq 0x70990b(%rip), %rax    # 0x8ec1f0
movq %rax, 0xc456b4(%rip)    # 0xe27fa0
jmp 0x1e2938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e290a
leaq 0x40488f(%rip), %rax    # 0x5e7190
movq %rax, 0xc45698(%rip)    # 0xe27fa0
jmp 0x1e2936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2926
leaq 0x12a3d3(%rip), %rax    # 0x30ccf0
movq %rax, 0xc4567c(%rip)    # 0xe27fa0
jmp 0x1e2934
leaq 0xb6903(%rip), %rax     # 0x299230
movq %rax, 0xc4566c(%rip)    # 0xe27fa0
jmp 0x1e2936
jmp 0x1e2938
movq 0xc45661(%rip), %rax    # 0xe27fa0
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_scan_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_scan_32_pointer = parasail_sg_qb_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_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 0x1e29ae
leaq 0x716afb(%rip), %rax    # 0x8f94a0
movq %rax, 0xc455fc(%rip)    # 0xe27fa8
jmp 0x1e29f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e29ca
leaq 0x40f21f(%rip), %rax    # 0x5f1be0
movq %rax, 0xc455e0(%rip)    # 0xe27fa8
jmp 0x1e29f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e29e6
leaq 0x134003(%rip), %rax    # 0x3169e0
movq %rax, 0xc455c4(%rip)    # 0xe27fa8
jmp 0x1e29f4
leaq 0xb6843(%rip), %rax     # 0x299230
movq %rax, 0xc455b4(%rip)    # 0xe27fa8
jmp 0x1e29f6
jmp 0x1e29f8
movq 0xc455a9(%rip), %rax    # 0xe27fa8
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_scan_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_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_scan_16_pointer = parasail_sg_qb_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_16_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_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 0x1e2a6e
leaq 0x7252ab(%rip), %rax    # 0x907d10
movq %rax, 0xc45544(%rip)    # 0xe27fb0
jmp 0x1e2ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2a8a
leaq 0x41a28f(%rip), %rax    # 0x5fcd10
movq %rax, 0xc45528(%rip)    # 0xe27fb0
jmp 0x1e2ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2aa6
leaq 0x13e2a3(%rip), %rax    # 0x320d40
movq %rax, 0xc4550c(%rip)    # 0xe27fb0
jmp 0x1e2ab4
leaq 0xb6783(%rip), %rax     # 0x299230
movq %rax, 0xc454fc(%rip)    # 0xe27fb0
jmp 0x1e2ab6
jmp 0x1e2ab8
movq 0xc454f1(%rip), %rax    # 0xe27fb0
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_scan_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_scan_8_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_stats_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 0x1e2b2e
leaq 0x7361db(%rip), %rax    # 0x918d00
movq %rax, 0xc4548c(%rip)    # 0xe27fb8
jmp 0x1e2b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2b4a
leaq 0x425dbf(%rip), %rax    # 0x608900
movq %rax, 0xc45470(%rip)    # 0xe27fb8
jmp 0x1e2b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2b66
leaq 0x149213(%rip), %rax    # 0x32bd70
movq %rax, 0xc45454(%rip)    # 0xe27fb8
jmp 0x1e2b74
leaq 0xb66c3(%rip), %rax     # 0x299230
movq %rax, 0xc45444(%rip)    # 0xe27fb8
jmp 0x1e2b76
jmp 0x1e2b78
movq 0xc45439(%rip), %rax    # 0xe27fb8
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_striped_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x1e2bee
leaq 0x786e4b(%rip), %rax    # 0x969a30
movq %rax, 0xc453d4(%rip)    # 0xe27fc0
jmp 0x1e2c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2c0a
leaq 0x45df3f(%rip), %rax    # 0x640b40
movq %rax, 0xc453b8(%rip)    # 0xe27fc0
jmp 0x1e2c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2c26
leaq 0x17f603(%rip), %rax    # 0x362220
movq %rax, 0xc4539c(%rip)    # 0xe27fc0
jmp 0x1e2c34
leaq 0xb46a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc4538c(%rip)    # 0xe27fc0
jmp 0x1e2c36
jmp 0x1e2c38
movq 0xc45381(%rip), %rax    # 0xe27fc0
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_striped_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x1e2cae
leaq 0x791d4b(%rip), %rax    # 0x9749f0
movq %rax, 0xc4531c(%rip)    # 0xe27fc8
jmp 0x1e2cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2cca
leaq 0x46731f(%rip), %rax    # 0x649fe0
movq %rax, 0xc45300(%rip)    # 0xe27fc8
jmp 0x1e2cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2ce6
leaq 0x1882e3(%rip), %rax    # 0x36afc0
movq %rax, 0xc452e4(%rip)    # 0xe27fc8
jmp 0x1e2cf4
leaq 0xb45e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc452d4(%rip)    # 0xe27fc8
jmp 0x1e2cf6
jmp 0x1e2cf8
movq 0xc452c9(%rip), %rax    # 0xe27fc8
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_striped_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x1e2d6e
leaq 0x79d8cb(%rip), %rax    # 0x980630
movq %rax, 0xc45264(%rip)    # 0xe27fd0
jmp 0x1e2db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2d8a
leaq 0x470ccf(%rip), %rax    # 0x653a50
movq %rax, 0xc45248(%rip)    # 0xe27fd0
jmp 0x1e2db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2da6
leaq 0x191423(%rip), %rax    # 0x3741c0
movq %rax, 0xc4522c(%rip)    # 0xe27fd0
jmp 0x1e2db4
leaq 0xb4523(%rip), %rax     # 0x2972d0
movq %rax, 0xc4521c(%rip)    # 0xe27fd0
jmp 0x1e2db6
jmp 0x1e2db8
movq 0xc45211(%rip), %rax    # 0xe27fd0
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_striped_8_dispatcher
parasail_result_t* parasail_sg_qb_stats_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_striped_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x1e2e2e
leaq 0x7aad1b(%rip), %rax    # 0x98db40
movq %rax, 0xc451ac(%rip)    # 0xe27fd8
jmp 0x1e2e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2e4a
leaq 0x47b31f(%rip), %rax    # 0x65e160
movq %rax, 0xc45190(%rip)    # 0xe27fd8
jmp 0x1e2e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2e66
leaq 0x19b243(%rip), %rax    # 0x37e0a0
movq %rax, 0xc45174(%rip)    # 0xe27fd8
jmp 0x1e2e74
leaq 0xb4463(%rip), %rax     # 0x2972d0
movq %rax, 0xc45164(%rip)    # 0xe27fd8
jmp 0x1e2e76
jmp 0x1e2e78
movq 0xc45159(%rip), %rax    # 0xe27fd8
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_diag_64_dispatcher
parasail_result_t* parasail_sg_qb_stats_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_64_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x1e2eee
leaq 0x74427b(%rip), %rax    # 0x927160
movq %rax, 0xc450f4(%rip)    # 0xe27fe0
jmp 0x1e2f38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2f0a
leaq 0x42ff3f(%rip), %rax    # 0x612e40
movq %rax, 0xc450d8(%rip)    # 0xe27fe0
jmp 0x1e2f36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2f26
leaq 0x152a93(%rip), %rax    # 0x3359b0
movq %rax, 0xc450bc(%rip)    # 0xe27fe0
jmp 0x1e2f34
leaq 0xb43a3(%rip), %rax     # 0x2972d0
movq %rax, 0xc450ac(%rip)    # 0xe27fe0
jmp 0x1e2f36
jmp 0x1e2f38
movq 0xc450a1(%rip), %rax    # 0xe27fe0
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_diag_32_dispatcher
parasail_result_t* parasail_sg_qb_stats_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_32_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x1e2fae
leaq 0x7512bb(%rip), %rax    # 0x934260
movq %rax, 0xc4503c(%rip)    # 0xe27fe8
jmp 0x1e2ff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e2fca
leaq 0x43991f(%rip), %rax    # 0x61c8e0
movq %rax, 0xc45020(%rip)    # 0xe27fe8
jmp 0x1e2ff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e2fe6
leaq 0x15be73(%rip), %rax    # 0x33ee50
movq %rax, 0xc45004(%rip)    # 0xe27fe8
jmp 0x1e2ff4
leaq 0xb42e3(%rip), %rax     # 0x2972d0
movq %rax, 0xc44ff4(%rip)    # 0xe27fe8
jmp 0x1e2ff6
jmp 0x1e2ff8
movq 0xc44fe9(%rip), %rax    # 0xe27fe8
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_diag_16_dispatcher
parasail_result_t* parasail_sg_qb_stats_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_16_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_stats_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 0x1e306e
leaq 0x7615db(%rip), %rax    # 0x944640
movq %rax, 0xc44f84(%rip)    # 0xe27ff0
jmp 0x1e30b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e308a
leaq 0x444abf(%rip), %rax    # 0x627b40
movq %rax, 0xc44f68(%rip)    # 0xe27ff0
jmp 0x1e30b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e30a6
leaq 0x166963(%rip), %rax    # 0x349a00
movq %rax, 0xc44f4c(%rip)    # 0xe27ff0
jmp 0x1e30b4
leaq 0xb4223(%rip), %rax     # 0x2972d0
movq %rax, 0xc44f3c(%rip)    # 0xe27ff0
jmp 0x1e30b6
jmp 0x1e30b8
movq 0xc44f31(%rip), %rax    # 0xe27ff0
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_diag_8_dispatcher
parasail_result_t* parasail_sg_qb_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_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qb_stats_diag_8_pointer = parasail_sg_qb;
    }
    return parasail_sg_qb_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 0x1e312e
leaq 0x7778bb(%rip), %rax    # 0x95a9e0
movq %rax, 0xc44ecc(%rip)    # 0xe27ff8
jmp 0x1e3178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e314a
leaq 0x4527ef(%rip), %rax    # 0x635930
movq %rax, 0xc44eb0(%rip)    # 0xe27ff8
jmp 0x1e3176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3166
leaq 0x174493(%rip), %rax    # 0x3575f0
movq %rax, 0xc44e94(%rip)    # 0xe27ff8
jmp 0x1e3174
leaq 0xb4163(%rip), %rax     # 0x2972d0
movq %rax, 0xc44e84(%rip)    # 0xe27ff8
jmp 0x1e3176
jmp 0x1e3178
movq 0xc44e79(%rip), %rax    # 0xe27ff8
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_64_dispatcher
parasail_result_t* parasail_sg_qb_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_table_scan_64_pointer = parasail_sg_qb_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_64_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e31ee
leaq 0x7b672b(%rip), %rax    # 0x999910
movq %rax, 0xc44e14(%rip)    # 0xe28000
jmp 0x1e3238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e320a
leaq 0x48266f(%rip), %rax    # 0x665870
movq %rax, 0xc44df8(%rip)    # 0xe28000
jmp 0x1e3236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e3226
leaq 0x1a4683(%rip), %rax    # 0x3878a0
movq %rax, 0xc44ddc(%rip)    # 0xe28000
jmp 0x1e3234
leaq 0xb6003(%rip), %rax     # 0x299230
movq %rax, 0xc44dcc(%rip)    # 0xe28000
jmp 0x1e3236
jmp 0x1e3238
movq 0xc44dc1(%rip), %rax    # 0xe28000
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_32_dispatcher
parasail_result_t* parasail_sg_qb_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_table_scan_32_pointer = parasail_sg_qb_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qb_table_scan_32_pointer = parasail_sg_qb_scan;
    }
    return parasail_sg_qb_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 0x1e32ae
leaq 0x7bd08b(%rip), %rax    # 0x9a0330
movq %rax, 0xc44d5c(%rip)    # 0xe28008
jmp 0x1e32f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1e32ca
leaq 0x487aff(%rip), %rax    # 0x66adc0
movq %rax, 0xc44d40(%rip)    # 0xe28008
jmp 0x1e32f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1e32e6
leaq 0x1a9db3(%rip), %rax    # 0x38d090
movq %rax, 0xc44d24(%rip)    # 0xe28008
jmp 0x1e32f4
leaq 0xb5f43(%rip), %rax     # 0x299230
movq %rax, 0xc44d14(%rip)    # 0xe28008
jmp 0x1e32f6
jmp 0x1e32f8
movq 0xc44d09(%rip), %rax    # 0xe28008
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)