LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_db_dispatch.c
// Function: parasail_sg_db_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_db_stats_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_striped_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1fd5ee
leaq 0x77755b(%rip), %rax    # 0x974b40
movq %rax, 0xc2b6fc(%rip)    # 0xe28ce8
jmp 0x1fd638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fd60a
leaq 0x44cb2f(%rip), %rax    # 0x64a130
movq %rax, 0xc2b6e0(%rip)    # 0xe28ce8
jmp 0x1fd636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fd626
leaq 0x16daf3(%rip), %rax    # 0x36b110
movq %rax, 0xc2b6c4(%rip)    # 0xe28ce8
jmp 0x1fd634
leaq 0x99df3(%rip), %rax     # 0x297420
movq %rax, 0xc2b6b4(%rip)    # 0xe28ce8
jmp 0x1fd636
jmp 0x1fd638
movq 0xc2b6a9(%rip), %rax    # 0xe28ce8
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_db_dispatch.c
// Function: parasail_sg_db_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_db_stats_striped_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_striped_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1fd6ae
leaq 0x7830db(%rip), %rax    # 0x980780
movq %rax, 0xc2b644(%rip)    # 0xe28cf0
jmp 0x1fd6f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fd6ca
leaq 0x4564df(%rip), %rax    # 0x653ba0
movq %rax, 0xc2b628(%rip)    # 0xe28cf0
jmp 0x1fd6f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fd6e6
leaq 0x176c33(%rip), %rax    # 0x374310
movq %rax, 0xc2b60c(%rip)    # 0xe28cf0
jmp 0x1fd6f4
leaq 0x99d33(%rip), %rax     # 0x297420
movq %rax, 0xc2b5fc(%rip)    # 0xe28cf0
jmp 0x1fd6f6
jmp 0x1fd6f8
movq 0xc2b5f1(%rip), %rax    # 0xe28cf0
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_db_dispatch.c
// Function: parasail_sg_db_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_striped_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fd76e
leaq 0x79052b(%rip), %rax    # 0x98dc90
movq %rax, 0xc2b58c(%rip)    # 0xe28cf8
jmp 0x1fd7b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fd78a
leaq 0x460b2f(%rip), %rax    # 0x65e2b0
movq %rax, 0xc2b570(%rip)    # 0xe28cf8
jmp 0x1fd7b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fd7a6
leaq 0x180a53(%rip), %rax    # 0x37e1f0
movq %rax, 0xc2b554(%rip)    # 0xe28cf8
jmp 0x1fd7b4
leaq 0x99c73(%rip), %rax     # 0x297420
movq %rax, 0xc2b544(%rip)    # 0xe28cf8
jmp 0x1fd7b6
jmp 0x1fd7b8
movq 0xc2b539(%rip), %rax    # 0xe28cf8
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fd82e
leaq 0x729a8b(%rip), %rax    # 0x9272b0
movq %rax, 0xc2b4d4(%rip)    # 0xe28d00
jmp 0x1fd878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fd84a
leaq 0x41574f(%rip), %rax    # 0x612f90
movq %rax, 0xc2b4b8(%rip)    # 0xe28d00
jmp 0x1fd876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fd866
leaq 0x1382a3(%rip), %rax    # 0x335b00
movq %rax, 0xc2b49c(%rip)    # 0xe28d00
jmp 0x1fd874
leaq 0x99bb3(%rip), %rax     # 0x297420
movq %rax, 0xc2b48c(%rip)    # 0xe28d00
jmp 0x1fd876
jmp 0x1fd878
movq 0xc2b481(%rip), %rax    # 0xe28d00
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fd8ee
leaq 0x736acb(%rip), %rax    # 0x9343b0
movq %rax, 0xc2b41c(%rip)    # 0xe28d08
jmp 0x1fd938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fd90a
leaq 0x41f12f(%rip), %rax    # 0x61ca30
movq %rax, 0xc2b400(%rip)    # 0xe28d08
jmp 0x1fd936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fd926
leaq 0x141683(%rip), %rax    # 0x33efa0
movq %rax, 0xc2b3e4(%rip)    # 0xe28d08
jmp 0x1fd934
leaq 0x99af3(%rip), %rax     # 0x297420
movq %rax, 0xc2b3d4(%rip)    # 0xe28d08
jmp 0x1fd936
jmp 0x1fd938
movq 0xc2b3c9(%rip), %rax    # 0xe28d08
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fd9ae
leaq 0x746deb(%rip), %rax    # 0x944790
movq %rax, 0xc2b364(%rip)    # 0xe28d10
jmp 0x1fd9f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fd9ca
leaq 0x42a2cf(%rip), %rax    # 0x627c90
movq %rax, 0xc2b348(%rip)    # 0xe28d10
jmp 0x1fd9f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fd9e6
leaq 0x14c173(%rip), %rax    # 0x349b50
movq %rax, 0xc2b32c(%rip)    # 0xe28d10
jmp 0x1fd9f4
leaq 0x99a33(%rip), %rax     # 0x297420
movq %rax, 0xc2b31c(%rip)    # 0xe28d10
jmp 0x1fd9f6
jmp 0x1fd9f8
movq 0xc2b311(%rip), %rax    # 0xe28d10
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_db_dispatch.c
// Function: parasail_sg_db_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_stats_diag_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fda6e
leaq 0x75d0cb(%rip), %rax    # 0x95ab30
movq %rax, 0xc2b2ac(%rip)    # 0xe28d18
jmp 0x1fdab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fda8a
leaq 0x437fff(%rip), %rax    # 0x635a80
movq %rax, 0xc2b290(%rip)    # 0xe28d18
jmp 0x1fdab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fdaa6
leaq 0x159ca3(%rip), %rax    # 0x357740
movq %rax, 0xc2b274(%rip)    # 0xe28d18
jmp 0x1fdab4
leaq 0x99973(%rip), %rax     # 0x297420
movq %rax, 0xc2b264(%rip)    # 0xe28d18
jmp 0x1fdab6
jmp 0x1fdab8
movq 0xc2b259(%rip), %rax    # 0xe28d18
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_64_pointer = parasail_sg_db_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1fdb2e
leaq 0x79bf3b(%rip), %rax    # 0x999a60
movq %rax, 0xc2b1f4(%rip)    # 0xe28d20
jmp 0x1fdb78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fdb4a
leaq 0x467e7f(%rip), %rax    # 0x6659c0
movq %rax, 0xc2b1d8(%rip)    # 0xe28d20
jmp 0x1fdb76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fdb66
leaq 0x189e93(%rip), %rax    # 0x3879f0
movq %rax, 0xc2b1bc(%rip)    # 0xe28d20
jmp 0x1fdb74
leaq 0x9b813(%rip), %rax     # 0x299380
movq %rax, 0xc2b1ac(%rip)    # 0xe28d20
jmp 0x1fdb76
jmp 0x1fdb78
movq 0xc2b1a1(%rip), %rax    # 0xe28d20
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_32_pointer = parasail_sg_db_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_32_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1fdbee
leaq 0x7a289b(%rip), %rax    # 0x9a0480
movq %rax, 0xc2b13c(%rip)    # 0xe28d28
jmp 0x1fdc38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fdc0a
leaq 0x46d30f(%rip), %rax    # 0x66af10
movq %rax, 0xc2b120(%rip)    # 0xe28d28
jmp 0x1fdc36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fdc26
leaq 0x18f5c3(%rip), %rax    # 0x38d1e0
movq %rax, 0xc2b104(%rip)    # 0xe28d28
jmp 0x1fdc34
leaq 0x9b753(%rip), %rax     # 0x299380
movq %rax, 0xc2b0f4(%rip)    # 0xe28d28
jmp 0x1fdc36
jmp 0x1fdc38
movq 0xc2b0e9(%rip), %rax    # 0xe28d28
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_16_pointer = parasail_sg_db_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_16_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1fdcae
leaq 0x7aa55b(%rip), %rax    # 0x9a8200
movq %rax, 0xc2b084(%rip)    # 0xe28d30
jmp 0x1fdcf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fdcca
leaq 0x472ebf(%rip), %rax    # 0x670b80
movq %rax, 0xc2b068(%rip)    # 0xe28d30
jmp 0x1fdcf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fdce6
leaq 0x195303(%rip), %rax    # 0x392fe0
movq %rax, 0xc2b04c(%rip)    # 0xe28d30
jmp 0x1fdcf4
leaq 0x9b693(%rip), %rax     # 0x299380
movq %rax, 0xc2b03c(%rip)    # 0xe28d30
jmp 0x1fdcf6
jmp 0x1fdcf8
movq 0xc2b031(%rip), %rax    # 0xe28d30
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_db_dispatch.c
// Function: parasail_sg_db_table_scan_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_scan_8_pointer = parasail_sg_db_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_table_scan_8_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1fdd6e
leaq 0x7b46cb(%rip), %rax    # 0x9b2430
movq %rax, 0xc2afcc(%rip)    # 0xe28d38
jmp 0x1fddb8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fdd8a
leaq 0x4796cf(%rip), %rax    # 0x677450
movq %rax, 0xc2afb0(%rip)    # 0xe28d38
jmp 0x1fddb6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fdda6
leaq 0x19be93(%rip), %rax    # 0x399c30
movq %rax, 0xc2af94(%rip)    # 0xe28d38
jmp 0x1fddb4
leaq 0x9b5d3(%rip), %rax     # 0x299380
movq %rax, 0xc2af84(%rip)    # 0xe28d38
jmp 0x1fddb6
jmp 0x1fddb8
movq 0xc2af79(%rip), %rax    # 0xe28d38
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_64_pointer = parasail_sg_db_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fde2e
leaq 0x7ef78b(%rip), %rax    # 0x9ed5b0
movq %rax, 0xc2af14(%rip)    # 0xe28d40
jmp 0x1fde78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fde4a
leaq 0x49f49f(%rip), %rax    # 0x69d2e0
movq %rax, 0xc2aef8(%rip)    # 0xe28d40
jmp 0x1fde76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fde66
leaq 0x1c2c73(%rip), %rax    # 0x3c0ad0
movq %rax, 0xc2aedc(%rip)    # 0xe28d40
jmp 0x1fde74
leaq 0x995b3(%rip), %rax     # 0x297420
movq %rax, 0xc2aecc(%rip)    # 0xe28d40
jmp 0x1fde76
jmp 0x1fde78
movq 0xc2aec1(%rip), %rax    # 0xe28d40
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_32_pointer = parasail_sg_db_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fdeee
leaq 0x7f52db(%rip), %rax    # 0x9f31c0
movq %rax, 0xc2ae5c(%rip)    # 0xe28d48
jmp 0x1fdf38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fdf0a
leaq 0x4a419f(%rip), %rax    # 0x6a20a0
movq %rax, 0xc2ae40(%rip)    # 0xe28d48
jmp 0x1fdf36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fdf26
leaq 0x1c7bb3(%rip), %rax    # 0x3c5ad0
movq %rax, 0xc2ae24(%rip)    # 0xe28d48
jmp 0x1fdf34
leaq 0x994f3(%rip), %rax     # 0x297420
movq %rax, 0xc2ae14(%rip)    # 0xe28d48
jmp 0x1fdf36
jmp 0x1fdf38
movq 0xc2ae09(%rip), %rax    # 0xe28d48
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_16_pointer = parasail_sg_db_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fdfae
leaq 0x7fbc8b(%rip), %rax    # 0x9f9c30
movq %rax, 0xc2ada4(%rip)    # 0xe28d50
jmp 0x1fdff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fdfca
leaq 0x4a94af(%rip), %rax    # 0x6a7470
movq %rax, 0xc2ad88(%rip)    # 0xe28d50
jmp 0x1fdff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fdfe6
leaq 0x1ccfd3(%rip), %rax    # 0x3cafb0
movq %rax, 0xc2ad6c(%rip)    # 0xe28d50
jmp 0x1fdff4
leaq 0x99433(%rip), %rax     # 0x297420
movq %rax, 0xc2ad5c(%rip)    # 0xe28d50
jmp 0x1fdff6
jmp 0x1fdff8
movq 0xc2ad51(%rip), %rax    # 0xe28d50
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_db_dispatch.c
// Function: parasail_sg_db_table_striped_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_striped_8_pointer = parasail_sg_db_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_table_striped_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fe06e
leaq 0x80438b(%rip), %rax    # 0xa023f0
movq %rax, 0xc2acec(%rip)    # 0xe28d58
jmp 0x1fe0b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fe08a
leaq 0x4af4bf(%rip), %rax    # 0x6ad540
movq %rax, 0xc2acd0(%rip)    # 0xe28d58
jmp 0x1fe0b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fe0a6
leaq 0x1d3353(%rip), %rax    # 0x3d13f0
movq %rax, 0xc2acb4(%rip)    # 0xe28d58
jmp 0x1fe0b4
leaq 0x99373(%rip), %rax     # 0x297420
movq %rax, 0xc2aca4(%rip)    # 0xe28d58
jmp 0x1fe0b6
jmp 0x1fe0b8
movq 0xc2ac99(%rip), %rax    # 0xe28d58
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_db_dispatch.c
// Function: parasail_sg_db_table_diag_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_diag_64_pointer = parasail_sg_db_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_64_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fe12e
leaq 0x7bd1eb(%rip), %rax    # 0x9bb310
movq %rax, 0xc2ac34(%rip)    # 0xe28d60
jmp 0x1fe178
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fe14a
leaq 0x47f5bf(%rip), %rax    # 0x67d700
movq %rax, 0xc2ac18(%rip)    # 0xe28d60
jmp 0x1fe176
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fe166
leaq 0x1a1f23(%rip), %rax    # 0x3a0080
movq %rax, 0xc2abfc(%rip)    # 0xe28d60
jmp 0x1fe174
leaq 0x992b3(%rip), %rax     # 0x297420
movq %rax, 0xc2abec(%rip)    # 0xe28d60
jmp 0x1fe176
jmp 0x1fe178
movq 0xc2abe1(%rip), %rax    # 0xe28d60
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_db_dispatch.c
// Function: parasail_sg_db_table_diag_32_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_diag_32_pointer = parasail_sg_db_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_32_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fe1ee
leaq 0x7c5c0b(%rip), %rax    # 0x9c3df0
movq %rax, 0xc2ab7c(%rip)    # 0xe28d68
jmp 0x1fe238
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fe20a
leaq 0x48564f(%rip), %rax    # 0x683850
movq %rax, 0xc2ab60(%rip)    # 0xe28d68
jmp 0x1fe236
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fe226
leaq 0x1a8263(%rip), %rax    # 0x3a6480
movq %rax, 0xc2ab44(%rip)    # 0xe28d68
jmp 0x1fe234
leaq 0x991f3(%rip), %rax     # 0x297420
movq %rax, 0xc2ab34(%rip)    # 0xe28d68
jmp 0x1fe236
jmp 0x1fe238
movq 0xc2ab29(%rip), %rax    # 0xe28d68
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_db_dispatch.c
// Function: parasail_sg_db_table_diag_16_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_diag_16_pointer = parasail_sg_db_table_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db_table_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_16_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fe2ae
leaq 0x7d1deb(%rip), %rax    # 0x9d0090
movq %rax, 0xc2aac4(%rip)    # 0xe28d70
jmp 0x1fe2f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fe2ca
leaq 0x48d06f(%rip), %rax    # 0x68b330
movq %rax, 0xc2aaa8(%rip)    # 0xe28d70
jmp 0x1fe2f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fe2e6
leaq 0x1afea3(%rip), %rax    # 0x3ae180
movq %rax, 0xc2aa8c(%rip)    # 0xe28d70
jmp 0x1fe2f4
leaq 0x99133(%rip), %rax     # 0x297420
movq %rax, 0xc2aa7c(%rip)    # 0xe28d70
jmp 0x1fe2f6
jmp 0x1fe2f8
movq 0xc2aa71(%rip), %rax    # 0xe28d70
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_db_dispatch.c
// Function: parasail_sg_db_table_diag_8_dispatcher
parasail_result_t* parasail_sg_db_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_db_table_diag_8_pointer = parasail_sg_db_table_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db_table_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_db_table_diag_8_pointer = parasail_sg_db;
    }
    return parasail_sg_db_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 0x1fe36e
leaq 0x7e49eb(%rip), %rax    # 0x9e2d50
movq %rax, 0xc2aa0c(%rip)    # 0xe28d78
jmp 0x1fe3b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fe38a
leaq 0x497bbf(%rip), %rax    # 0x695f40
movq %rax, 0xc2a9f0(%rip)    # 0xe28d78
jmp 0x1fe3b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fe3a6
leaq 0x1bb063(%rip), %rax    # 0x3b9400
movq %rax, 0xc2a9d4(%rip)    # 0xe28d78
jmp 0x1fe3b4
leaq 0x99073(%rip), %rax     # 0x297420
movq %rax, 0xc2a9c4(%rip)    # 0xe28d78
jmp 0x1fe3b6
jmp 0x1fe3b8
movq 0xc2a9b9(%rip), %rax    # 0xe28d78
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_db_dispatch.c
// Function: parasail_sg_db_stats_table_scan_64_dispatcher
parasail_result_t* parasail_sg_db_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_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_stats_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_db_stats_table_scan_64_pointer = parasail_sg_db_scan;
    }
    return parasail_sg_db_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 0x1fe42e
leaq 0x80fefb(%rip), %rax    # 0xa0e320
movq %rax, 0xc2a954(%rip)    # 0xe28d80
jmp 0x1fe478
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1fe44a
leaq 0x4ba20f(%rip), %rax    # 0x6b8650
movq %rax, 0xc2a938(%rip)    # 0xe28d80
jmp 0x1fe476
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1fe466
leaq 0x1dbf13(%rip), %rax    # 0x3da370
movq %rax, 0xc2a91c(%rip)    # 0xe28d80
jmp 0x1fe474
leaq 0x9af13(%rip), %rax     # 0x299380
movq %rax, 0xc2a90c(%rip)    # 0xe28d80
jmp 0x1fe476
jmp 0x1fe478
movq 0xc2a901(%rip), %rax    # 0xe28d80
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)