LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_rowcol_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1edb6e
leaq 0x95d0bb(%rip), %rax    # 0xb4ac20
movq %rax, 0xc3aa1c(%rip)    # 0xe28588
jmp 0x1edbb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1edb8a
leaq 0x5afeff(%rip), %rax    # 0x79da80
movq %rax, 0xc3aa00(%rip)    # 0xe28588
jmp 0x1edbb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1edba6
leaq 0x2cb1e3(%rip), %rax    # 0x4b8d80
movq %rax, 0xc3a9e4(%rip)    # 0xe28588
jmp 0x1edbb4
leaq 0xab6f3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3a9d4(%rip)    # 0xe28588
jmp 0x1edbb6
jmp 0x1edbb8
movq 0xc3a9c9(%rip), %rax    # 0xe28588
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_rowcol_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1edc2e
leaq 0x96cacb(%rip), %rax    # 0xb5a6f0
movq %rax, 0xc3a964(%rip)    # 0xe28590
jmp 0x1edc78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1edc4a
leaq 0x5bbc6f(%rip), %rax    # 0x7a98b0
movq %rax, 0xc3a948(%rip)    # 0xe28590
jmp 0x1edc76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1edc66
leaq 0x2d61f3(%rip), %rax    # 0x4c3e50
movq %rax, 0xc3a92c(%rip)    # 0xe28590
jmp 0x1edc74
leaq 0xab633(%rip), %rax     # 0x2992a0
movq %rax, 0xc3a91c(%rip)    # 0xe28590
jmp 0x1edc76
jmp 0x1edc78
movq 0xc3a911(%rip), %rax    # 0xe28590
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_stats_rowcol_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_stats_rowcol_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1edcee
leaq 0x97f40b(%rip), %rax    # 0xb6d0f0
movq %rax, 0xc3a8ac(%rip)    # 0xe28598
jmp 0x1edd38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1edd0a
leaq 0x5c87ff(%rip), %rax    # 0x7b6500
movq %rax, 0xc3a890(%rip)    # 0xe28598
jmp 0x1edd36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1edd26
leaq 0x2e21e3(%rip), %rax    # 0x4cff00
movq %rax, 0xc3a874(%rip)    # 0xe28598
jmp 0x1edd34
leaq 0xab573(%rip), %rax     # 0x2992a0
movq %rax, 0xc3a864(%rip)    # 0xe28598
jmp 0x1edd36
jmp 0x1edd38
movq 0xc3a859(%rip), %rax    # 0xe28598
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1eddae
leaq 0x9d900b(%rip), %rax    # 0xbc6db0
movq %rax, 0xc3a7f4(%rip)    # 0xe285a0
jmp 0x1eddf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1eddca
leaq 0x60552f(%rip), %rax    # 0x7f32f0
movq %rax, 0xc3a7d8(%rip)    # 0xe285a0
jmp 0x1eddf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1edde6
leaq 0x31d5d3(%rip), %rax    # 0x50b3b0
movq %rax, 0xc3a7bc(%rip)    # 0xe285a0
jmp 0x1eddf4
leaq 0xa9553(%rip), %rax     # 0x297340
movq %rax, 0xc3a7ac(%rip)    # 0xe285a0
jmp 0x1eddf6
jmp 0x1eddf8
movq 0xc3a7a1(%rip), %rax    # 0xe285a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ede6e
leaq 0x9e4c2b(%rip), %rax    # 0xbd2a90
movq %rax, 0xc3a73c(%rip)    # 0xe285a8
jmp 0x1edeb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ede8a
leaq 0x60f32f(%rip), %rax    # 0x7fd1b0
movq %rax, 0xc3a720(%rip)    # 0xe285a8
jmp 0x1edeb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1edea6
leaq 0x326e23(%rip), %rax    # 0x514cc0
movq %rax, 0xc3a704(%rip)    # 0xe285a8
jmp 0x1edeb4
leaq 0xa9493(%rip), %rax     # 0x297340
movq %rax, 0xc3a6f4(%rip)    # 0xe285a8
jmp 0x1edeb6
jmp 0x1edeb8
movq 0xc3a6e9(%rip), %rax    # 0xe285a8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1edf2e
leaq 0x9f18bb(%rip), %rax    # 0xbdf7e0
movq %rax, 0xc3a684(%rip)    # 0xe285b0
jmp 0x1edf78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1edf4a
leaq 0x6198cf(%rip), %rax    # 0x807810
movq %rax, 0xc3a668(%rip)    # 0xe285b0
jmp 0x1edf76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1edf66
leaq 0x330be3(%rip), %rax    # 0x51eb40
movq %rax, 0xc3a64c(%rip)    # 0xe285b0
jmp 0x1edf74
leaq 0xa93d3(%rip), %rax     # 0x297340
movq %rax, 0xc3a63c(%rip)    # 0xe285b0
jmp 0x1edf76
jmp 0x1edf78
movq 0xc3a631(%rip), %rax    # 0xe285b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe_stats_rowcol_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1edfee
leaq 0xa0065b(%rip), %rax    # 0xbee640
movq %rax, 0xc3a5cc(%rip)    # 0xe285b8
jmp 0x1ee038
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee00a
leaq 0x624e9f(%rip), %rax    # 0x812ea0
movq %rax, 0xc3a5b0(%rip)    # 0xe285b8
jmp 0x1ee036
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee026
leaq 0x33b9b3(%rip), %rax    # 0x5299d0
movq %rax, 0xc3a594(%rip)    # 0xe285b8
jmp 0x1ee034
leaq 0xa9313(%rip), %rax     # 0x297340
movq %rax, 0xc3a584(%rip)    # 0xe285b8
jmp 0x1ee036
jmp 0x1ee038
movq 0xc3a579(%rip), %rax    # 0xe285b8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_64_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ee0ae
leaq 0x98e62b(%rip), %rax    # 0xb7c6d0
movq %rax, 0xc3a514(%rip)    # 0xe285c0
jmp 0x1ee0f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee0ca
leaq 0x5d342f(%rip), %rax    # 0x7c14f0
movq %rax, 0xc3a4f8(%rip)    # 0xe285c0
jmp 0x1ee0f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee0e6
leaq 0x2ec603(%rip), %rax    # 0x4da6e0
movq %rax, 0xc3a4dc(%rip)    # 0xe285c0
jmp 0x1ee0f4
leaq 0xa9253(%rip), %rax     # 0x297340
movq %rax, 0xc3a4cc(%rip)    # 0xe285c0
jmp 0x1ee0f6
jmp 0x1ee0f8
movq 0xc3a4c1(%rip), %rax    # 0xe285c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_32_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ee16e
leaq 0x99c51b(%rip), %rax    # 0xb8a680
movq %rax, 0xc3a45c(%rip)    # 0xe285c8
jmp 0x1ee1b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee18a
leaq 0x5dd65f(%rip), %rax    # 0x7cb7e0
movq %rax, 0xc3a440(%rip)    # 0xe285c8
jmp 0x1ee1b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee1a6
leaq 0x2f6383(%rip), %rax    # 0x4e4520
movq %rax, 0xc3a424(%rip)    # 0xe285c8
jmp 0x1ee1b4
leaq 0xa9193(%rip), %rax     # 0x297340
movq %rax, 0xc3a414(%rip)    # 0xe285c8
jmp 0x1ee1b6
jmp 0x1ee1b8
movq 0xc3a409(%rip), %rax    # 0xe285c8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_16_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ee22e
leaq 0x9ae42b(%rip), %rax    # 0xb9c650
movq %rax, 0xc3a3a4(%rip)    # 0xe285d0
jmp 0x1ee278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee24a
leaq 0x5e962f(%rip), %rax    # 0x7d7870
movq %rax, 0xc3a388(%rip)    # 0xe285d0
jmp 0x1ee276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee266
leaq 0x301d13(%rip), %rax    # 0x4eff70
movq %rax, 0xc3a36c(%rip)    # 0xe285d0
jmp 0x1ee274
leaq 0xa90d3(%rip), %rax     # 0x297340
movq %rax, 0xc3a35c(%rip)    # 0xe285d0
jmp 0x1ee276
jmp 0x1ee278
movq 0xc3a351(%rip), %rax    # 0xe285d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_stats_rowcol_diag_8_dispatcher
parasail_result_t* parasail_sg_qe_stats_rowcol_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe_stats_rowcol_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_stats_rowcol_diag_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_stats_rowcol_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1ee2ee
leaq 0x9c7cdb(%rip), %rax    # 0xbb5fc0
movq %rax, 0xc3a2ec(%rip)    # 0xe285d8
jmp 0x1ee338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee30a
leaq 0x5f8d0f(%rip), %rax    # 0x7e7010
movq %rax, 0xc3a2d0(%rip)    # 0xe285d8
jmp 0x1ee336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee326
leaq 0x311293(%rip), %rax    # 0x4ff5b0
movq %rax, 0xc3a2b4(%rip)    # 0xe285d8
jmp 0x1ee334
leaq 0xa9013(%rip), %rax     # 0x297340
movq %rax, 0xc3a2a4(%rip)    # 0xe285d8
jmp 0x1ee336
jmp 0x1ee338
movq 0xc3a299(%rip), %rax    # 0xe285d8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_64_dispatcher
parasail_result_t* parasail_sg_qe_trace_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_trace_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_64_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_trace_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 0x1ee3ae
leaq 0xa0b0bb(%rip), %rax    # 0xbf9460
movq %rax, 0xc3a234(%rip)    # 0xe285e0
jmp 0x1ee3f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee3ca
leaq 0x62d39f(%rip), %rax    # 0x81b760
movq %rax, 0xc3a218(%rip)    # 0xe285e0
jmp 0x1ee3f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee3e6
leaq 0x343af3(%rip), %rax    # 0x531ed0
movq %rax, 0xc3a1fc(%rip)    # 0xe285e0
jmp 0x1ee3f4
leaq 0xaaeb3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3a1ec(%rip)    # 0xe285e0
jmp 0x1ee3f6
jmp 0x1ee3f8
movq 0xc3a1e1(%rip), %rax    # 0xe285e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_32_dispatcher
parasail_result_t* parasail_sg_qe_trace_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_trace_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_32_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_trace_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 0x1ee46e
leaq 0xa136fb(%rip), %rax    # 0xc01b60
movq %rax, 0xc3a17c(%rip)    # 0xe285e8
jmp 0x1ee4b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee48a
leaq 0x633c8f(%rip), %rax    # 0x822110
movq %rax, 0xc3a160(%rip)    # 0xe285e8
jmp 0x1ee4b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee4a6
leaq 0x34a4d3(%rip), %rax    # 0x538970
movq %rax, 0xc3a144(%rip)    # 0xe285e8
jmp 0x1ee4b4
leaq 0xaadf3(%rip), %rax     # 0x2992a0
movq %rax, 0xc3a134(%rip)    # 0xe285e8
jmp 0x1ee4b6
jmp 0x1ee4b8
movq 0xc3a129(%rip), %rax    # 0xe285e8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_16_dispatcher
parasail_result_t* parasail_sg_qe_trace_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_trace_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_16_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_trace_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 0x1ee52e
leaq 0xa1d7fb(%rip), %rax    # 0xc0bd20
movq %rax, 0xc3a0c4(%rip)    # 0xe285f0
jmp 0x1ee578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee54a
leaq 0x63b05f(%rip), %rax    # 0x8295a0
movq %rax, 0xc3a0a8(%rip)    # 0xe285f0
jmp 0x1ee576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee566
leaq 0x351a53(%rip), %rax    # 0x53ffb0
movq %rax, 0xc3a08c(%rip)    # 0xe285f0
jmp 0x1ee574
leaq 0xaad33(%rip), %rax     # 0x2992a0
movq %rax, 0xc3a07c(%rip)    # 0xe285f0
jmp 0x1ee576
jmp 0x1ee578
movq 0xc3a071(%rip), %rax    # 0xe285f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_scan_8_dispatcher
parasail_result_t* parasail_sg_qe_trace_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_trace_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_trace_scan_8_pointer = parasail_sg_qe_scan;
    }
    return parasail_sg_qe_trace_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 0x1ee5ee
leaq 0xa2ab4b(%rip), %rax    # 0xc19130
movq %rax, 0xc3a00c(%rip)    # 0xe285f8
jmp 0x1ee638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee60a
leaq 0x6436ff(%rip), %rax    # 0x831d00
movq %rax, 0xc39ff0(%rip)    # 0xe285f8
jmp 0x1ee636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee626
leaq 0x35a543(%rip), %rax    # 0x548b60
movq %rax, 0xc39fd4(%rip)    # 0xe285f8
jmp 0x1ee634
leaq 0xaac73(%rip), %rax     # 0x2992a0
movq %rax, 0xc39fc4(%rip)    # 0xe285f8
jmp 0x1ee636
jmp 0x1ee638
movq 0xc39fb9(%rip), %rax    # 0xe285f8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_64_dispatcher
parasail_result_t* parasail_sg_qe_trace_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe_trace_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_64_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1ee6ae
leaq 0xa742bb(%rip), %rax    # 0xc62960
movq %rax, 0xc39f54(%rip)    # 0xe28600
jmp 0x1ee6f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee6ca
leaq 0x6720ef(%rip), %rax    # 0x8607b0
movq %rax, 0xc39f38(%rip)    # 0xe28600
jmp 0x1ee6f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee6e6
leaq 0x389933(%rip), %rax    # 0x578010
movq %rax, 0xc39f1c(%rip)    # 0xe28600
jmp 0x1ee6f4
leaq 0xa8c53(%rip), %rax     # 0x297340
movq %rax, 0xc39f0c(%rip)    # 0xe28600
jmp 0x1ee6f6
jmp 0x1ee6f8
movq 0xc39f01(%rip), %rax    # 0xe28600
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_32_dispatcher
parasail_result_t* parasail_sg_qe_trace_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe_trace_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_32_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1ee76e
leaq 0xa7e0bb(%rip), %rax    # 0xc6c820
movq %rax, 0xc39e9c(%rip)    # 0xe28608
jmp 0x1ee7b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee78a
leaq 0x67a06f(%rip), %rax    # 0x8687f0
movq %rax, 0xc39e80(%rip)    # 0xe28608
jmp 0x1ee7b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee7a6
leaq 0x391863(%rip), %rax    # 0x580000
movq %rax, 0xc39e64(%rip)    # 0xe28608
jmp 0x1ee7b4
leaq 0xa8b93(%rip), %rax     # 0x297340
movq %rax, 0xc39e54(%rip)    # 0xe28608
jmp 0x1ee7b6
jmp 0x1ee7b8
movq 0xc39e49(%rip), %rax    # 0xe28608
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_16_dispatcher
parasail_result_t* parasail_sg_qe_trace_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe_trace_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_16_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1ee82e
leaq 0xa8992b(%rip), %rax    # 0xc78150
movq %rax, 0xc39de4(%rip)    # 0xe28610
jmp 0x1ee878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee84a
leaq 0x682ccf(%rip), %rax    # 0x871510
movq %rax, 0xc39dc8(%rip)    # 0xe28610
jmp 0x1ee876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee866
leaq 0x39a493(%rip), %rax    # 0x588cf0
movq %rax, 0xc39dac(%rip)    # 0xe28610
jmp 0x1ee874
leaq 0xa8ad3(%rip), %rax     # 0x297340
movq %rax, 0xc39d9c(%rip)    # 0xe28610
jmp 0x1ee876
jmp 0x1ee878
movq 0xc39d91(%rip), %rax    # 0xe28610
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qe_dispatch.c
// Function: parasail_sg_qe_trace_striped_8_dispatcher
parasail_result_t* parasail_sg_qe_trace_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe_trace_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qe_trace_striped_8_pointer = parasail_sg_qe;
    }
    return parasail_sg_qe_trace_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 0x1ee8ee
leaq 0xa980ab(%rip), %rax    # 0xc86990
movq %rax, 0xc39d2c(%rip)    # 0xe28618
jmp 0x1ee938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1ee90a
leaq 0x68cdaf(%rip), %rax    # 0x87b6b0
movq %rax, 0xc39d10(%rip)    # 0xe28618
jmp 0x1ee936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1ee926
leaq 0x3a4833(%rip), %rax    # 0x593150
movq %rax, 0xc39cf4(%rip)    # 0xe28618
jmp 0x1ee934
leaq 0xa8a13(%rip), %rax     # 0x297340
movq %rax, 0xc39ce4(%rip)    # 0xe28618
jmp 0x1ee936
jmp 0x1ee938
movq 0xc39cd9(%rip), %rax    # 0xe28618
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)