LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sg_de_dispatch.c
// Function: parasail_sg_de_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_de_stats_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x20616e
leaq 0x701d6b(%rip), %rax    # 0x907ed0
movq %rax, 0xc22fc4(%rip)    # 0xe29130
jmp 0x2061b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20618a
leaq 0x3f6d4f(%rip), %rax    # 0x5fced0
movq %rax, 0xc22fa8(%rip)    # 0xe29130
jmp 0x2061b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2061a6
leaq 0x11ad63(%rip), %rax    # 0x320f00
movq %rax, 0xc22f8c(%rip)    # 0xe29130
jmp 0x2061b4
leaq 0x93243(%rip), %rax     # 0x2993f0
movq %rax, 0xc22f7c(%rip)    # 0xe29130
jmp 0x2061b6
jmp 0x2061b8
movq 0xc22f71(%rip), %rax    # 0xe29130
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_de_dispatch.c
// Function: parasail_sg_de_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_de_stats_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x20622e
leaq 0x712c9b(%rip), %rax    # 0x918ec0
movq %rax, 0xc22f0c(%rip)    # 0xe29138
jmp 0x206278
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20624a
leaq 0x40287f(%rip), %rax    # 0x608ac0
movq %rax, 0xc22ef0(%rip)    # 0xe29138
jmp 0x206276
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206266
leaq 0x125cd3(%rip), %rax    # 0x32bf30
movq %rax, 0xc22ed4(%rip)    # 0xe29138
jmp 0x206274
leaq 0x93183(%rip), %rax     # 0x2993f0
movq %rax, 0xc22ec4(%rip)    # 0xe29138
jmp 0x206276
jmp 0x206278
movq 0xc22eb9(%rip), %rax    # 0xe29138
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_de_dispatch.c
// Function: parasail_sg_de_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_de_stats_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x2062ee
leaq 0x76390b(%rip), %rax    # 0x969bf0
movq %rax, 0xc22e54(%rip)    # 0xe29140
jmp 0x206338
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20630a
leaq 0x43a9ff(%rip), %rax    # 0x640d00
movq %rax, 0xc22e38(%rip)    # 0xe29140
jmp 0x206336
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206326
leaq 0x15c0c3(%rip), %rax    # 0x3623e0
movq %rax, 0xc22e1c(%rip)    # 0xe29140
jmp 0x206334
leaq 0x91163(%rip), %rax     # 0x297490
movq %rax, 0xc22e0c(%rip)    # 0xe29140
jmp 0x206336
jmp 0x206338
movq 0xc22e01(%rip), %rax    # 0xe29140
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_de_dispatch.c
// Function: parasail_sg_de_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x2063ae
leaq 0x76e80b(%rip), %rax    # 0x974bb0
movq %rax, 0xc22d9c(%rip)    # 0xe29148
jmp 0x2063f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2063ca
leaq 0x443ddf(%rip), %rax    # 0x64a1a0
movq %rax, 0xc22d80(%rip)    # 0xe29148
jmp 0x2063f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2063e6
leaq 0x164da3(%rip), %rax    # 0x36b180
movq %rax, 0xc22d64(%rip)    # 0xe29148
jmp 0x2063f4
leaq 0x910a3(%rip), %rax     # 0x297490
movq %rax, 0xc22d54(%rip)    # 0xe29148
jmp 0x2063f6
jmp 0x2063f8
movq 0xc22d49(%rip), %rax    # 0xe29148
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_de_dispatch.c
// Function: parasail_sg_de_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x20646e
leaq 0x77a38b(%rip), %rax    # 0x9807f0
movq %rax, 0xc22ce4(%rip)    # 0xe29150
jmp 0x2064b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20648a
leaq 0x44d78f(%rip), %rax    # 0x653c10
movq %rax, 0xc22cc8(%rip)    # 0xe29150
jmp 0x2064b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2064a6
leaq 0x16dee3(%rip), %rax    # 0x374380
movq %rax, 0xc22cac(%rip)    # 0xe29150
jmp 0x2064b4
leaq 0x90fe3(%rip), %rax     # 0x297490
movq %rax, 0xc22c9c(%rip)    # 0xe29150
jmp 0x2064b6
jmp 0x2064b8
movq 0xc22c91(%rip), %rax    # 0xe29150
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_de_dispatch.c
// Function: parasail_sg_de_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x20652e
leaq 0x7877db(%rip), %rax    # 0x98dd00
movq %rax, 0xc22c2c(%rip)    # 0xe29158
jmp 0x206578
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20654a
leaq 0x457ddf(%rip), %rax    # 0x65e320
movq %rax, 0xc22c10(%rip)    # 0xe29158
jmp 0x206576
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206566
leaq 0x177d03(%rip), %rax    # 0x37e260
movq %rax, 0xc22bf4(%rip)    # 0xe29158
jmp 0x206574
leaq 0x90f23(%rip), %rax     # 0x297490
movq %rax, 0xc22be4(%rip)    # 0xe29158
jmp 0x206576
jmp 0x206578
movq 0xc22bd9(%rip), %rax    # 0xe29158
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_de_dispatch.c
// Function: parasail_sg_de_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x2065ee
leaq 0x720d3b(%rip), %rax    # 0x927320
movq %rax, 0xc22b74(%rip)    # 0xe29160
jmp 0x206638
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20660a
leaq 0x40c9ff(%rip), %rax    # 0x613000
movq %rax, 0xc22b58(%rip)    # 0xe29160
jmp 0x206636
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206626
leaq 0x12f553(%rip), %rax    # 0x335b70
movq %rax, 0xc22b3c(%rip)    # 0xe29160
jmp 0x206634
leaq 0x90e63(%rip), %rax     # 0x297490
movq %rax, 0xc22b2c(%rip)    # 0xe29160
jmp 0x206636
jmp 0x206638
movq 0xc22b21(%rip), %rax    # 0xe29160
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_de_dispatch.c
// Function: parasail_sg_de_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x2066ae
leaq 0x72dd7b(%rip), %rax    # 0x934420
movq %rax, 0xc22abc(%rip)    # 0xe29168
jmp 0x2066f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2066ca
leaq 0x4163df(%rip), %rax    # 0x61caa0
movq %rax, 0xc22aa0(%rip)    # 0xe29168
jmp 0x2066f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2066e6
leaq 0x138933(%rip), %rax    # 0x33f010
movq %rax, 0xc22a84(%rip)    # 0xe29168
jmp 0x2066f4
leaq 0x90da3(%rip), %rax     # 0x297490
movq %rax, 0xc22a74(%rip)    # 0xe29168
jmp 0x2066f6
jmp 0x2066f8
movq 0xc22a69(%rip), %rax    # 0xe29168
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_de_dispatch.c
// Function: parasail_sg_de_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x20676e
leaq 0x73e09b(%rip), %rax    # 0x944800
movq %rax, 0xc22a04(%rip)    # 0xe29170
jmp 0x2067b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20678a
leaq 0x42157f(%rip), %rax    # 0x627d00
movq %rax, 0xc229e8(%rip)    # 0xe29170
jmp 0x2067b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2067a6
leaq 0x143423(%rip), %rax    # 0x349bc0
movq %rax, 0xc229cc(%rip)    # 0xe29170
jmp 0x2067b4
leaq 0x90ce3(%rip), %rax     # 0x297490
movq %rax, 0xc229bc(%rip)    # 0xe29170
jmp 0x2067b6
jmp 0x2067b8
movq 0xc229b1(%rip), %rax    # 0xe29170
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_de_dispatch.c
// Function: parasail_sg_de_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_de_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_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_stats_diag_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x20682e
leaq 0x75437b(%rip), %rax    # 0x95aba0
movq %rax, 0xc2294c(%rip)    # 0xe29178
jmp 0x206878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20684a
leaq 0x42f2af(%rip), %rax    # 0x635af0
movq %rax, 0xc22930(%rip)    # 0xe29178
jmp 0x206876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206866
leaq 0x150f53(%rip), %rax    # 0x3577b0
movq %rax, 0xc22914(%rip)    # 0xe29178
jmp 0x206874
leaq 0x90c23(%rip), %rax     # 0x297490
movq %rax, 0xc22904(%rip)    # 0xe29178
jmp 0x206876
jmp 0x206878
movq 0xc228f9(%rip), %rax    # 0xe29178
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_de_dispatch.c
// Function: parasail_sg_de_table_scan_64_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_scan_64_pointer = parasail_sg_de_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_64_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x2068ee
leaq 0x7931eb(%rip), %rax    # 0x999ad0
movq %rax, 0xc22894(%rip)    # 0xe29180
jmp 0x206938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x20690a
leaq 0x45f12f(%rip), %rax    # 0x665a30
movq %rax, 0xc22878(%rip)    # 0xe29180
jmp 0x206936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206926
leaq 0x181143(%rip), %rax    # 0x387a60
movq %rax, 0xc2285c(%rip)    # 0xe29180
jmp 0x206934
leaq 0x92ac3(%rip), %rax     # 0x2993f0
movq %rax, 0xc2284c(%rip)    # 0xe29180
jmp 0x206936
jmp 0x206938
movq 0xc22841(%rip), %rax    # 0xe29180
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_de_dispatch.c
// Function: parasail_sg_de_table_scan_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_scan_32_pointer = parasail_sg_de_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_32_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x2069ae
leaq 0x799b4b(%rip), %rax    # 0x9a04f0
movq %rax, 0xc227dc(%rip)    # 0xe29188
jmp 0x2069f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x2069ca
leaq 0x4645bf(%rip), %rax    # 0x66af80
movq %rax, 0xc227c0(%rip)    # 0xe29188
jmp 0x2069f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x2069e6
leaq 0x186873(%rip), %rax    # 0x38d250
movq %rax, 0xc227a4(%rip)    # 0xe29188
jmp 0x2069f4
leaq 0x92a03(%rip), %rax     # 0x2993f0
movq %rax, 0xc22794(%rip)    # 0xe29188
jmp 0x2069f6
jmp 0x2069f8
movq 0xc22789(%rip), %rax    # 0xe29188
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_de_dispatch.c
// Function: parasail_sg_de_table_scan_16_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_scan_16_pointer = parasail_sg_de_table_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_table_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_16_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x206a6e
leaq 0x7a180b(%rip), %rax    # 0x9a8270
movq %rax, 0xc22724(%rip)    # 0xe29190
jmp 0x206ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206a8a
leaq 0x46a16f(%rip), %rax    # 0x670bf0
movq %rax, 0xc22708(%rip)    # 0xe29190
jmp 0x206ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206aa6
leaq 0x18c5b3(%rip), %rax    # 0x393050
movq %rax, 0xc226ec(%rip)    # 0xe29190
jmp 0x206ab4
leaq 0x92943(%rip), %rax     # 0x2993f0
movq %rax, 0xc226dc(%rip)    # 0xe29190
jmp 0x206ab6
jmp 0x206ab8
movq 0xc226d1(%rip), %rax    # 0xe29190
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_de_dispatch.c
// Function: parasail_sg_de_table_scan_8_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_scan_8_pointer = parasail_sg_de_table_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_table_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_scan_8_pointer = parasail_sg_de_scan;
    }
    return parasail_sg_de_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 0x206b2e
leaq 0x7ab97b(%rip), %rax    # 0x9b24a0
movq %rax, 0xc2266c(%rip)    # 0xe29198
jmp 0x206b78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206b4a
leaq 0x47097f(%rip), %rax    # 0x6774c0
movq %rax, 0xc22650(%rip)    # 0xe29198
jmp 0x206b76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206b66
leaq 0x193143(%rip), %rax    # 0x399ca0
movq %rax, 0xc22634(%rip)    # 0xe29198
jmp 0x206b74
leaq 0x92883(%rip), %rax     # 0x2993f0
movq %rax, 0xc22624(%rip)    # 0xe29198
jmp 0x206b76
jmp 0x206b78
movq 0xc22619(%rip), %rax    # 0xe29198
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_64_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_striped_64_pointer = parasail_sg_de_table_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de_table_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x206bee
leaq 0x7e6a3b(%rip), %rax    # 0x9ed620
movq %rax, 0xc225b4(%rip)    # 0xe291a0
jmp 0x206c38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206c0a
leaq 0x49674f(%rip), %rax    # 0x69d350
movq %rax, 0xc22598(%rip)    # 0xe291a0
jmp 0x206c36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206c26
leaq 0x1b9f23(%rip), %rax    # 0x3c0b40
movq %rax, 0xc2257c(%rip)    # 0xe291a0
jmp 0x206c34
leaq 0x90863(%rip), %rax     # 0x297490
movq %rax, 0xc2256c(%rip)    # 0xe291a0
jmp 0x206c36
jmp 0x206c38
movq 0xc22561(%rip), %rax    # 0xe291a0
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_striped_32_pointer = parasail_sg_de_table_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de_table_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x206cae
leaq 0x7ec58b(%rip), %rax    # 0x9f3230
movq %rax, 0xc224fc(%rip)    # 0xe291a8
jmp 0x206cf8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206cca
leaq 0x49b44f(%rip), %rax    # 0x6a2110
movq %rax, 0xc224e0(%rip)    # 0xe291a8
jmp 0x206cf6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206ce6
leaq 0x1bee63(%rip), %rax    # 0x3c5b40
movq %rax, 0xc224c4(%rip)    # 0xe291a8
jmp 0x206cf4
leaq 0x907a3(%rip), %rax     # 0x297490
movq %rax, 0xc224b4(%rip)    # 0xe291a8
jmp 0x206cf6
jmp 0x206cf8
movq 0xc224a9(%rip), %rax    # 0xe291a8
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_16_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_striped_16_pointer = parasail_sg_de_table_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de_table_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_16_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x206d6e
leaq 0x7f2f3b(%rip), %rax    # 0x9f9ca0
movq %rax, 0xc22444(%rip)    # 0xe291b0
jmp 0x206db8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206d8a
leaq 0x4a075f(%rip), %rax    # 0x6a74e0
movq %rax, 0xc22428(%rip)    # 0xe291b0
jmp 0x206db6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206da6
leaq 0x1c4283(%rip), %rax    # 0x3cb020
movq %rax, 0xc2240c(%rip)    # 0xe291b0
jmp 0x206db4
leaq 0x906e3(%rip), %rax     # 0x297490
movq %rax, 0xc223fc(%rip)    # 0xe291b0
jmp 0x206db6
jmp 0x206db8
movq 0xc223f1(%rip), %rax    # 0xe291b0
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_de_dispatch.c
// Function: parasail_sg_de_table_striped_8_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_striped_8_pointer = parasail_sg_de_table_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de_table_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_de_table_striped_8_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x206e2e
leaq 0x7fb63b(%rip), %rax    # 0xa02460
movq %rax, 0xc2238c(%rip)    # 0xe291b8
jmp 0x206e78
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206e4a
leaq 0x4a676f(%rip), %rax    # 0x6ad5b0
movq %rax, 0xc22370(%rip)    # 0xe291b8
jmp 0x206e76
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206e66
leaq 0x1ca603(%rip), %rax    # 0x3d1460
movq %rax, 0xc22354(%rip)    # 0xe291b8
jmp 0x206e74
leaq 0x90623(%rip), %rax     # 0x297490
movq %rax, 0xc22344(%rip)    # 0xe291b8
jmp 0x206e76
jmp 0x206e78
movq 0xc22339(%rip), %rax    # 0xe291b8
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_de_dispatch.c
// Function: parasail_sg_de_table_diag_64_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_diag_64_pointer = parasail_sg_de_table_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de_table_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_64_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x206eee
leaq 0x7b449b(%rip), %rax    # 0x9bb380
movq %rax, 0xc222d4(%rip)    # 0xe291c0
jmp 0x206f38
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206f0a
leaq 0x47686f(%rip), %rax    # 0x67d770
movq %rax, 0xc222b8(%rip)    # 0xe291c0
jmp 0x206f36
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206f26
leaq 0x1991d3(%rip), %rax    # 0x3a00f0
movq %rax, 0xc2229c(%rip)    # 0xe291c0
jmp 0x206f34
leaq 0x90563(%rip), %rax     # 0x297490
movq %rax, 0xc2228c(%rip)    # 0xe291c0
jmp 0x206f36
jmp 0x206f38
movq 0xc22281(%rip), %rax    # 0xe291c0
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_de_dispatch.c
// Function: parasail_sg_de_table_diag_32_dispatcher
parasail_result_t* parasail_sg_de_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_de_table_diag_32_pointer = parasail_sg_de_table_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de_table_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_de_table_diag_32_pointer = parasail_sg_de;
    }
    return parasail_sg_de_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 0x206fae
leaq 0x7bcebb(%rip), %rax    # 0x9c3e60
movq %rax, 0xc2221c(%rip)    # 0xe291c8
jmp 0x206ff8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x206fca
leaq 0x47c8ff(%rip), %rax    # 0x6838c0
movq %rax, 0xc22200(%rip)    # 0xe291c8
jmp 0x206ff6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x206fe6
leaq 0x19f513(%rip), %rax    # 0x3a64f0
movq %rax, 0xc221e4(%rip)    # 0xe291c8
jmp 0x206ff4
leaq 0x904a3(%rip), %rax     # 0x297490
movq %rax, 0xc221d4(%rip)    # 0xe291c8
jmp 0x206ff6
jmp 0x206ff8
movq 0xc221c9(%rip), %rax    # 0xe291c8
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)