LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_qx_dispatch.c
// Function: parasail_sg_qx_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x1f49ae
leaq 0x79927b(%rip), %rax    # 0x98dc20
movq %rax, 0xc33eec(%rip)    # 0xe28898
jmp 0x1f49f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f49ca
leaq 0x46987f(%rip), %rax    # 0x65e240
movq %rax, 0xc33ed0(%rip)    # 0xe28898
jmp 0x1f49f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f49e6
leaq 0x1897a3(%rip), %rax    # 0x37e180
movq %rax, 0xc33eb4(%rip)    # 0xe28898
jmp 0x1f49f4
leaq 0xa29c3(%rip), %rax     # 0x2973b0
movq %rax, 0xc33ea4(%rip)    # 0xe28898
jmp 0x1f49f6
jmp 0x1f49f8
movq 0xc33e99(%rip), %rax    # 0xe28898
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x1f4a6e
leaq 0x7327db(%rip), %rax    # 0x927240
movq %rax, 0xc33e34(%rip)    # 0xe288a0
jmp 0x1f4ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4a8a
leaq 0x41e49f(%rip), %rax    # 0x612f20
movq %rax, 0xc33e18(%rip)    # 0xe288a0
jmp 0x1f4ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4aa6
leaq 0x140ff3(%rip), %rax    # 0x335a90
movq %rax, 0xc33dfc(%rip)    # 0xe288a0
jmp 0x1f4ab4
leaq 0xa2903(%rip), %rax     # 0x2973b0
movq %rax, 0xc33dec(%rip)    # 0xe288a0
jmp 0x1f4ab6
jmp 0x1f4ab8
movq 0xc33de1(%rip), %rax    # 0xe288a0
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x1f4b2e
leaq 0x73f81b(%rip), %rax    # 0x934340
movq %rax, 0xc33d7c(%rip)    # 0xe288a8
jmp 0x1f4b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4b4a
leaq 0x427e7f(%rip), %rax    # 0x61c9c0
movq %rax, 0xc33d60(%rip)    # 0xe288a8
jmp 0x1f4b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4b66
leaq 0x14a3d3(%rip), %rax    # 0x33ef30
movq %rax, 0xc33d44(%rip)    # 0xe288a8
jmp 0x1f4b74
leaq 0xa2843(%rip), %rax     # 0x2973b0
movq %rax, 0xc33d34(%rip)    # 0xe288a8
jmp 0x1f4b76
jmp 0x1f4b78
movq 0xc33d29(%rip), %rax    # 0xe288a8
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x1f4bee
leaq 0x74fb3b(%rip), %rax    # 0x944720
movq %rax, 0xc33cc4(%rip)    # 0xe288b0
jmp 0x1f4c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4c0a
leaq 0x43301f(%rip), %rax    # 0x627c20
movq %rax, 0xc33ca8(%rip)    # 0xe288b0
jmp 0x1f4c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4c26
leaq 0x154ec3(%rip), %rax    # 0x349ae0
movq %rax, 0xc33c8c(%rip)    # 0xe288b0
jmp 0x1f4c34
leaq 0xa2783(%rip), %rax     # 0x2973b0
movq %rax, 0xc33c7c(%rip)    # 0xe288b0
jmp 0x1f4c36
jmp 0x1f4c38
movq 0xc33c71(%rip), %rax    # 0xe288b0
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_stats_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_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 0x1f4cae
leaq 0x765e1b(%rip), %rax    # 0x95aac0
movq %rax, 0xc33c0c(%rip)    # 0xe288b8
jmp 0x1f4cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4cca
leaq 0x440d4f(%rip), %rax    # 0x635a10
movq %rax, 0xc33bf0(%rip)    # 0xe288b8
jmp 0x1f4cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4ce6
leaq 0x1629f3(%rip), %rax    # 0x3576d0
movq %rax, 0xc33bd4(%rip)    # 0xe288b8
jmp 0x1f4cf4
leaq 0xa26c3(%rip), %rax     # 0x2973b0
movq %rax, 0xc33bc4(%rip)    # 0xe288b8
jmp 0x1f4cf6
jmp 0x1f4cf8
movq 0xc33bb9(%rip), %rax    # 0xe288b8
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_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x1f4d6e
leaq 0x7a4c8b(%rip), %rax    # 0x9999f0
movq %rax, 0xc33b54(%rip)    # 0xe288c0
jmp 0x1f4db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4d8a
leaq 0x470bcf(%rip), %rax    # 0x665950
movq %rax, 0xc33b38(%rip)    # 0xe288c0
jmp 0x1f4db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4da6
leaq 0x192be3(%rip), %rax    # 0x387980
movq %rax, 0xc33b1c(%rip)    # 0xe288c0
jmp 0x1f4db4
leaq 0xa4563(%rip), %rax     # 0x299310
movq %rax, 0xc33b0c(%rip)    # 0xe288c0
jmp 0x1f4db6
jmp 0x1f4db8
movq 0xc33b01(%rip), %rax    # 0xe288c0
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_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_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_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_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 0x1f4e2e
leaq 0x7ab5eb(%rip), %rax    # 0x9a0410
movq %rax, 0xc33a9c(%rip)    # 0xe288c8
jmp 0x1f4e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4e4a
leaq 0x47605f(%rip), %rax    # 0x66aea0
movq %rax, 0xc33a80(%rip)    # 0xe288c8
jmp 0x1f4e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4e66
leaq 0x198313(%rip), %rax    # 0x38d170
movq %rax, 0xc33a64(%rip)    # 0xe288c8
jmp 0x1f4e74
leaq 0xa44a3(%rip), %rax     # 0x299310
movq %rax, 0xc33a54(%rip)    # 0xe288c8
jmp 0x1f4e76
jmp 0x1f4e78
movq 0xc33a49(%rip), %rax    # 0xe288c8
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_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f4eee
leaq 0x7b32ab(%rip), %rax    # 0x9a8190
movq %rax, 0xc339e4(%rip)    # 0xe288d0
jmp 0x1f4f38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4f0a
leaq 0x47bc0f(%rip), %rax    # 0x670b10
movq %rax, 0xc339c8(%rip)    # 0xe288d0
jmp 0x1f4f36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4f26
leaq 0x19e053(%rip), %rax    # 0x392f70
movq %rax, 0xc339ac(%rip)    # 0xe288d0
jmp 0x1f4f34
leaq 0xa43e3(%rip), %rax     # 0x299310
movq %rax, 0xc3399c(%rip)    # 0xe288d0
jmp 0x1f4f36
jmp 0x1f4f38
movq 0xc33991(%rip), %rax    # 0xe288d0
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_qx_dispatch.c
// Function: parasail_sg_qx_table_scan_8_dispatcher
parasail_result_t* parasail_sg_qx_table_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_scan_8_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_table_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f4fae
leaq 0x7bd41b(%rip), %rax    # 0x9b23c0
movq %rax, 0xc3392c(%rip)    # 0xe288d8
jmp 0x1f4ff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f4fca
leaq 0x48241f(%rip), %rax    # 0x6773e0
movq %rax, 0xc33910(%rip)    # 0xe288d8
jmp 0x1f4ff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f4fe6
leaq 0x1a4be3(%rip), %rax    # 0x399bc0
movq %rax, 0xc338f4(%rip)    # 0xe288d8
jmp 0x1f4ff4
leaq 0xa4323(%rip), %rax     # 0x299310
movq %rax, 0xc338e4(%rip)    # 0xe288d8
jmp 0x1f4ff6
jmp 0x1f4ff8
movq 0xc338d9(%rip), %rax    # 0xe288d8
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_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_64_dispatcher
parasail_result_t* parasail_sg_qx_table_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f506e
leaq 0x7f84db(%rip), %rax    # 0x9ed540
movq %rax, 0xc33874(%rip)    # 0xe288e0
jmp 0x1f50b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f508a
leaq 0x4a81ef(%rip), %rax    # 0x69d270
movq %rax, 0xc33858(%rip)    # 0xe288e0
jmp 0x1f50b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f50a6
leaq 0x1cb9c3(%rip), %rax    # 0x3c0a60
movq %rax, 0xc3383c(%rip)    # 0xe288e0
jmp 0x1f50b4
leaq 0xa2303(%rip), %rax     # 0x2973b0
movq %rax, 0xc3382c(%rip)    # 0xe288e0
jmp 0x1f50b6
jmp 0x1f50b8
movq 0xc33821(%rip), %rax    # 0xe288e0
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_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_32_dispatcher
parasail_result_t* parasail_sg_qx_table_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f512e
leaq 0x7fe02b(%rip), %rax    # 0x9f3150
movq %rax, 0xc337bc(%rip)    # 0xe288e8
jmp 0x1f5178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f514a
leaq 0x4aceef(%rip), %rax    # 0x6a2030
movq %rax, 0xc337a0(%rip)    # 0xe288e8
jmp 0x1f5176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5166
leaq 0x1d0903(%rip), %rax    # 0x3c5a60
movq %rax, 0xc33784(%rip)    # 0xe288e8
jmp 0x1f5174
leaq 0xa2243(%rip), %rax     # 0x2973b0
movq %rax, 0xc33774(%rip)    # 0xe288e8
jmp 0x1f5176
jmp 0x1f5178
movq 0xc33769(%rip), %rax    # 0xe288e8
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_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_16_dispatcher
parasail_result_t* parasail_sg_qx_table_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f51ee
leaq 0x8049db(%rip), %rax    # 0x9f9bc0
movq %rax, 0xc33704(%rip)    # 0xe288f0
jmp 0x1f5238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f520a
leaq 0x4b21ff(%rip), %rax    # 0x6a7400
movq %rax, 0xc336e8(%rip)    # 0xe288f0
jmp 0x1f5236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5226
leaq 0x1d5d23(%rip), %rax    # 0x3caf40
movq %rax, 0xc336cc(%rip)    # 0xe288f0
jmp 0x1f5234
leaq 0xa2183(%rip), %rax     # 0x2973b0
movq %rax, 0xc336bc(%rip)    # 0xe288f0
jmp 0x1f5236
jmp 0x1f5238
movq 0xc336b1(%rip), %rax    # 0xe288f0
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_qx_dispatch.c
// Function: parasail_sg_qx_table_striped_8_dispatcher
parasail_result_t* parasail_sg_qx_table_striped_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_striped_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f52ae
leaq 0x80d0db(%rip), %rax    # 0xa02380
movq %rax, 0xc3364c(%rip)    # 0xe288f8
jmp 0x1f52f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f52ca
leaq 0x4b820f(%rip), %rax    # 0x6ad4d0
movq %rax, 0xc33630(%rip)    # 0xe288f8
jmp 0x1f52f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f52e6
leaq 0x1dc0a3(%rip), %rax    # 0x3d1380
movq %rax, 0xc33614(%rip)    # 0xe288f8
jmp 0x1f52f4
leaq 0xa20c3(%rip), %rax     # 0x2973b0
movq %rax, 0xc33604(%rip)    # 0xe288f8
jmp 0x1f52f6
jmp 0x1f52f8
movq 0xc335f9(%rip), %rax    # 0xe288f8
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_64_dispatcher
parasail_result_t* parasail_sg_qx_table_diag_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_64_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f536e
leaq 0x7c5f3b(%rip), %rax    # 0x9bb2a0
movq %rax, 0xc33594(%rip)    # 0xe28900
jmp 0x1f53b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f538a
leaq 0x48830f(%rip), %rax    # 0x67d690
movq %rax, 0xc33578(%rip)    # 0xe28900
jmp 0x1f53b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f53a6
leaq 0x1aac73(%rip), %rax    # 0x3a0010
movq %rax, 0xc3355c(%rip)    # 0xe28900
jmp 0x1f53b4
leaq 0xa2003(%rip), %rax     # 0x2973b0
movq %rax, 0xc3354c(%rip)    # 0xe28900
jmp 0x1f53b6
jmp 0x1f53b8
movq 0xc33541(%rip), %rax    # 0xe28900
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_32_dispatcher
parasail_result_t* parasail_sg_qx_table_diag_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_32_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f542e
leaq 0x7ce95b(%rip), %rax    # 0x9c3d80
movq %rax, 0xc334dc(%rip)    # 0xe28908
jmp 0x1f5478
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f544a
leaq 0x48e39f(%rip), %rax    # 0x6837e0
movq %rax, 0xc334c0(%rip)    # 0xe28908
jmp 0x1f5476
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5466
leaq 0x1b0fb3(%rip), %rax    # 0x3a6410
movq %rax, 0xc334a4(%rip)    # 0xe28908
jmp 0x1f5474
leaq 0xa1f43(%rip), %rax     # 0x2973b0
movq %rax, 0xc33494(%rip)    # 0xe28908
jmp 0x1f5476
jmp 0x1f5478
movq 0xc33489(%rip), %rax    # 0xe28908
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_16_dispatcher
parasail_result_t* parasail_sg_qx_table_diag_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_16_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f54ee
leaq 0x7dab3b(%rip), %rax    # 0x9d0020
movq %rax, 0xc33424(%rip)    # 0xe28910
jmp 0x1f5538
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f550a
leaq 0x495dbf(%rip), %rax    # 0x68b2c0
movq %rax, 0xc33408(%rip)    # 0xe28910
jmp 0x1f5536
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5526
leaq 0x1b8bf3(%rip), %rax    # 0x3ae110
movq %rax, 0xc333ec(%rip)    # 0xe28910
jmp 0x1f5534
leaq 0xa1e83(%rip), %rax     # 0x2973b0
movq %rax, 0xc333dc(%rip)    # 0xe28910
jmp 0x1f5536
jmp 0x1f5538
movq 0xc333d1(%rip), %rax    # 0xe28910
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_qx_dispatch.c
// Function: parasail_sg_qx_table_diag_8_dispatcher
parasail_result_t* parasail_sg_qx_table_diag_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_qx_table_diag_8_pointer = parasail_sg_qx;
    }
    return parasail_sg_qx_table_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f55ae
leaq 0x7ed73b(%rip), %rax    # 0x9e2ce0
movq %rax, 0xc3336c(%rip)    # 0xe28918
jmp 0x1f55f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f55ca
leaq 0x4a090f(%rip), %rax    # 0x695ed0
movq %rax, 0xc33350(%rip)    # 0xe28918
jmp 0x1f55f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f55e6
leaq 0x1c3db3(%rip), %rax    # 0x3b9390
movq %rax, 0xc33334(%rip)    # 0xe28918
jmp 0x1f55f4
leaq 0xa1dc3(%rip), %rax     # 0x2973b0
movq %rax, 0xc33324(%rip)    # 0xe28918
jmp 0x1f55f6
jmp 0x1f55f8
movq 0xc33319(%rip), %rax    # 0xe28918
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_64_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f566e
leaq 0x818c4b(%rip), %rax    # 0xa0e2b0
movq %rax, 0xc332b4(%rip)    # 0xe28920
jmp 0x1f56b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f568a
leaq 0x4c2f5f(%rip), %rax    # 0x6b85e0
movq %rax, 0xc33298(%rip)    # 0xe28920
jmp 0x1f56b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f56a6
leaq 0x1e4c63(%rip), %rax    # 0x3da300
movq %rax, 0xc3327c(%rip)    # 0xe28920
jmp 0x1f56b4
leaq 0xa3c63(%rip), %rax     # 0x299310
movq %rax, 0xc3326c(%rip)    # 0xe28920
jmp 0x1f56b6
jmp 0x1f56b8
movq 0xc33261(%rip), %rax    # 0xe28920
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_32_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_stats_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_32_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f572e
leaq 0x8265bb(%rip), %rax    # 0xa1bce0
movq %rax, 0xc331fc(%rip)    # 0xe28928
jmp 0x1f5778
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f574a
leaq 0x4cdddf(%rip), %rax    # 0x6c3520
movq %rax, 0xc331e0(%rip)    # 0xe28928
jmp 0x1f5776
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5766
leaq 0x1eee33(%rip), %rax    # 0x3e4590
movq %rax, 0xc331c4(%rip)    # 0xe28928
jmp 0x1f5774
leaq 0xa3ba3(%rip), %rax     # 0x299310
movq %rax, 0xc331b4(%rip)    # 0xe28928
jmp 0x1f5776
jmp 0x1f5778
movq 0xc331a9(%rip), %rax    # 0xe28928
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_qx_dispatch.c
// Function: parasail_sg_qx_stats_table_scan_16_dispatcher
parasail_result_t* parasail_sg_qx_stats_table_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_stats_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_qx_stats_table_scan_16_pointer = parasail_sg_qx_scan;
    }
    return parasail_sg_qx_stats_table_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1f57ee
leaq 0x8359eb(%rip), %rax    # 0xa2b1d0
movq %rax, 0xc33144(%rip)    # 0xe28930
jmp 0x1f5838
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1f580a
leaq 0x4d953f(%rip), %rax    # 0x6ced40
movq %rax, 0xc33128(%rip)    # 0xe28930
jmp 0x1f5836
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1f5826
leaq 0x1f9813(%rip), %rax    # 0x3ef030
movq %rax, 0xc3310c(%rip)    # 0xe28930
jmp 0x1f5834
leaq 0xa3ae3(%rip), %rax     # 0x299310
movq %rax, 0xc330fc(%rip)    # 0xe28930
jmp 0x1f5836
jmp 0x1f5838
movq 0xc330f1(%rip), %rax    # 0xe28930
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)