LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_scan_8_dispatcher
parasail_result_t* parasail_sg_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_scan_8_pointer = parasail_sg_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_scan_8_pointer = parasail_sg_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b27c4
leaq 0x2a7a28(%rip), %rax    # 0x45a1ea
jmp 0x1b27f3
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b27d8
leaq 0x1b4c8d(%rip), %rax    # 0x367463
jmp 0x1b27f3
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b27ec
leaq 0x8b1e2(%rip), %rax     # 0x23d9cc
jmp 0x1b27f3
leaq 0xa44e7(%rip), %rax     # 0x256cda
movq %rax, 0x588e9e(%rip)    # 0x73b698
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_64_dispatcher
parasail_result_t* parasail_sg_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_striped_64_pointer = parasail_sg_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_64_pointer = parasail_sg_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b284d
leaq 0x2b3603(%rip), %rax    # 0x465e4e
jmp 0x1b287c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2861
leaq 0x1be8b1(%rip), %rax    # 0x371110
jmp 0x1b287c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2875
leaq 0x8a0eb(%rip), %rax     # 0x23c95e
jmp 0x1b287c
leaq 0xafde2(%rip), %rax     # 0x26265e
movq %rax, 0x588e1d(%rip)    # 0x73b6a0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_32_dispatcher
parasail_result_t* parasail_sg_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_striped_32_pointer = parasail_sg_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_32_pointer = parasail_sg_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b28d6
leaq 0x2b4ff4(%rip), %rax    # 0x4678c8
jmp 0x1b2905
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b28ea
leaq 0x1c0217(%rip), %rax    # 0x372aff
jmp 0x1b2905
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b28fe
leaq 0x8a062(%rip), %rax     # 0x23c95e
jmp 0x1b2905
leaq 0xb1baf(%rip), %rax     # 0x2644b4
movq %rax, 0x588d9c(%rip)    # 0x73b6a8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_16_dispatcher
parasail_result_t* parasail_sg_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_striped_16_pointer = parasail_sg_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_16_pointer = parasail_sg_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b295f
leaq 0x2b6901(%rip), %rax    # 0x46925e
jmp 0x1b298e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2973
leaq 0x1c1afb(%rip), %rax    # 0x37446c
jmp 0x1b298e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2987
leaq 0x89fd9(%rip), %rax     # 0x23c95e
jmp 0x1b298e
leaq 0xb3591(%rip), %rax     # 0x265f1f
movq %rax, 0x588d1b(%rip)    # 0x73b6b0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_striped_8_dispatcher
parasail_result_t* parasail_sg_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_striped_8_pointer = parasail_sg_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_striped_8_pointer = parasail_sg_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b29e8
leaq 0x2b8204(%rip), %rax    # 0x46abea
jmp 0x1b2a17
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b29fc
leaq 0x1c33cf(%rip), %rax    # 0x375dc9
jmp 0x1b2a17
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2a10
leaq 0x89f50(%rip), %rax     # 0x23c95e
jmp 0x1b2a17
leaq 0xb516c(%rip), %rax     # 0x267b83
movq %rax, 0x588c9a(%rip)    # 0x73b6b8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_diag_64_dispatcher
parasail_result_t* parasail_sg_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_diag_64_pointer = parasail_sg_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_64_pointer = parasail_sg_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2a71
leaq 0x2a97f5(%rip), %rax    # 0x45c264
jmp 0x1b2aa0
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2a85
leaq 0x1b6785(%rip), %rax    # 0x369208
jmp 0x1b2aa0
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2a99
leaq 0x89ec7(%rip), %rax     # 0x23c95e
jmp 0x1b2aa0
leaq 0xa6690(%rip), %rax     # 0x259130
movq %rax, 0x588c19(%rip)    # 0x73b6c0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_diag_32_dispatcher
parasail_result_t* parasail_sg_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_diag_32_pointer = parasail_sg_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_32_pointer = parasail_sg_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2afa
leaq 0x2ab6fe(%rip), %rax    # 0x45e1f6
jmp 0x1b2b29
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2b0e
leaq 0x1b8265(%rip), %rax    # 0x36ad71
jmp 0x1b2b29
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2b22
leaq 0x89e3e(%rip), %rax     # 0x23c95e
jmp 0x1b2b29
leaq 0xa85ca(%rip), %rax     # 0x25b0f3
movq %rax, 0x588b98(%rip)    # 0x73b6c8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_diag_16_dispatcher
parasail_result_t* parasail_sg_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_diag_16_pointer = parasail_sg_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_16_pointer = parasail_sg_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2b83
leaq 0x2adbde(%rip), %rax    # 0x46075f
jmp 0x1b2bb2
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2b97
leaq 0x1b9ec3(%rip), %rax    # 0x36ca58
jmp 0x1b2bb2
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2bab
leaq 0x89db5(%rip), %rax     # 0x23c95e
jmp 0x1b2bb2
leaq 0xaa54a(%rip), %rax     # 0x25d0fc
movq %rax, 0x588b17(%rip)    # 0x73b6d0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_diag_8_dispatcher
parasail_result_t* parasail_sg_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_diag_8_pointer = parasail_sg_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_diag_8_pointer = parasail_sg_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2c0c
leaq 0x2b0beb(%rip), %rax    # 0x4637f5
jmp 0x1b2c3b
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2c20
leaq 0x1bc2a4(%rip), %rax    # 0x36eec2
jmp 0x1b2c3b
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2c34
leaq 0x89d2c(%rip), %rax     # 0x23c95e
jmp 0x1b2c3b
leaq 0xad0f6(%rip), %rax     # 0x25fd31
movq %rax, 0x588a96(%rip)    # 0x73b6d8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_scan_64_dispatcher
parasail_result_t* parasail_sg_stats_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_64_pointer = parasail_sg_stats_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2c95
leaq 0x2bb59a(%rip), %rax    # 0x46e22d
jmp 0x1b2cc4
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2ca9
leaq 0x1c6bd1(%rip), %rax    # 0x379878
jmp 0x1b2cc4
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2cbd
leaq 0x8ad11(%rip), %rax     # 0x23d9cc
jmp 0x1b2cc4
leaq 0xb8c71(%rip), %rax     # 0x26b935
movq %rax, 0x588a15(%rip)    # 0x73b6e0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_scan_32_dispatcher
parasail_result_t* parasail_sg_stats_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_32_pointer = parasail_sg_stats_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2d1e
leaq 0x2becba(%rip), %rax    # 0x4719d6
jmp 0x1b2d4d
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2d32
leaq 0x1ca1f3(%rip), %rax    # 0x37cf23
jmp 0x1b2d4d
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2d46
leaq 0x8ac88(%rip), %rax     # 0x23d9cc
jmp 0x1b2d4d
leaq 0xbcbc9(%rip), %rax     # 0x26f916
movq %rax, 0x588994(%rip)    # 0x73b6e8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_scan_16_dispatcher
parasail_result_t* parasail_sg_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_stats_scan_16_pointer = parasail_sg_stats_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_16_pointer = parasail_sg_stats_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_scan_16_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2da7
leaq 0x2c1f62(%rip), %rax    # 0x474d07
jmp 0x1b2dd6
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2dbb
leaq 0x1cd4b5(%rip), %rax    # 0x38026e
jmp 0x1b2dd6
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2dcf
leaq 0x8abff(%rip), %rax     # 0x23d9cc
jmp 0x1b2dd6
leaq 0xc0311(%rip), %rax     # 0x2730e7
movq %rax, 0x588913(%rip)    # 0x73b6f0
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_scan_8_dispatcher
parasail_result_t* parasail_sg_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_stats_scan_8_pointer = parasail_sg_stats_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_scan_8_pointer = parasail_sg_stats_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_scan_8_pointer = parasail_sg_scan;
    }
    return parasail_sg_stats_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2e30
leaq 0x2c520d(%rip), %rax    # 0x47803b
jmp 0x1b2e5f
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2e44
leaq 0x1d07db(%rip), %rax    # 0x38361d
jmp 0x1b2e5f
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2e58
leaq 0x8ab76(%rip), %rax     # 0x23d9cc
jmp 0x1b2e5f
leaq 0xc3be7(%rip), %rax     # 0x276a46
movq %rax, 0x588892(%rip)    # 0x73b6f8
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_striped_64_dispatcher
parasail_result_t* parasail_sg_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_stats_striped_64_pointer = parasail_sg_stats_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_64_pointer = parasail_sg_stats_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_striped_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2eb9
leaq 0x2d91c9(%rip), %rax    # 0x48c080
jmp 0x1b2ee8
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2ecd
leaq 0x1e29b7(%rip), %rax    # 0x395882
jmp 0x1b2ee8
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2ee1
leaq 0x89a7f(%rip), %rax     # 0x23c95e
jmp 0x1b2ee8
leaq 0xd8d60(%rip), %rax     # 0x28bc48
movq %rax, 0x588811(%rip)    # 0x73b700
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_striped_32_dispatcher
parasail_result_t* parasail_sg_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_stats_striped_32_pointer = parasail_sg_stats_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_32_pointer = parasail_sg_stats_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_striped_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2f42
leaq 0x2dc55c(%rip), %rax    # 0x48f49c
jmp 0x1b2f71
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2f56
leaq 0x1e5e11(%rip), %rax    # 0x398d65
jmp 0x1b2f71
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2f6a
leaq 0x899f6(%rip), %rax     # 0x23c95e
jmp 0x1b2f71
leaq 0xdca19(%rip), %rax     # 0x28f98a
movq %rax, 0x588790(%rip)    # 0x73b708
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_striped_16_dispatcher
parasail_result_t* parasail_sg_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_stats_striped_16_pointer = parasail_sg_stats_striped_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_16_pointer = parasail_sg_stats_striped_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_striped_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b2fcb
leaq 0x2df60e(%rip), %rax    # 0x4925d7
jmp 0x1b2ffa
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b2fdf
leaq 0x1e9014(%rip), %rax    # 0x39bff1
jmp 0x1b2ffa
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b2ff3
leaq 0x8996d(%rip), %rax     # 0x23c95e
jmp 0x1b2ffa
leaq 0xdff8c(%rip), %rax     # 0x292f86
movq %rax, 0x58870f(%rip)    # 0x73b710
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_striped_8_dispatcher
parasail_result_t* parasail_sg_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_stats_striped_8_pointer = parasail_sg_stats_striped_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_striped_8_pointer = parasail_sg_stats_striped_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_striped_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_striped_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3054
leaq 0x2e27b2(%rip), %rax    # 0x495804
jmp 0x1b3083
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3068
leaq 0x1ec263(%rip), %rax    # 0x39f2c9
jmp 0x1b3083
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b307c
leaq 0x898e4(%rip), %rax     # 0x23c95e
jmp 0x1b3083
leaq 0xe3745(%rip), %rax     # 0x2967c8
movq %rax, 0x58868e(%rip)    # 0x73b718
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_diag_64_dispatcher
parasail_result_t* parasail_sg_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_stats_diag_64_pointer = parasail_sg_stats_diag_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_64_pointer = parasail_sg_stats_diag_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_stats_diag_64_pointer = parasail_sg;
    }
    return parasail_sg_stats_diag_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b30dd
leaq 0x2c8904(%rip), %rax    # 0x47b9df
jmp 0x1b310c
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b30f1
leaq 0x1d3e03(%rip), %rax    # 0x386ef2
jmp 0x1b310c
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3105
leaq 0x8985b(%rip), %rax     # 0x23c95e
jmp 0x1b310c
leaq 0xc7c9e(%rip), %rax     # 0x27adaa
movq %rax, 0x58860d(%rip)    # 0x73b720
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_diag_32_dispatcher
parasail_result_t* parasail_sg_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_stats_diag_32_pointer = parasail_sg_stats_diag_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_32_pointer = parasail_sg_stats_diag_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_stats_diag_32_pointer = parasail_sg;
    }
    return parasail_sg_stats_diag_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3166
leaq 0x2cbfc4(%rip), %rax    # 0x47f128
jmp 0x1b3195
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b317a
leaq 0x1d72f4(%rip), %rax    # 0x38a46c
jmp 0x1b3195
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b318e
leaq 0x897d2(%rip), %rax     # 0x23c95e
jmp 0x1b3195
leaq 0xcb90b(%rip), %rax     # 0x27eaa0
movq %rax, 0x58858c(%rip)    # 0x73b728
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_diag_16_dispatcher
parasail_result_t* parasail_sg_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_stats_diag_16_pointer = parasail_sg_stats_diag_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_16_pointer = parasail_sg_stats_diag_neon_128_16;
    }
    else
#endif
    {
        parasail_sg_stats_diag_16_pointer = parasail_sg;
    }
    return parasail_sg_stats_diag_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b31ef
leaq 0x2cfea0(%rip), %rax    # 0x48308d
jmp 0x1b321e
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3203
leaq 0x1da95a(%rip), %rax    # 0x38db5b
jmp 0x1b321e
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3217
leaq 0x89749(%rip), %rax     # 0x23c95e
jmp 0x1b321e
leaq 0xcf30e(%rip), %rax     # 0x28252c
movq %rax, 0x58850b(%rip)    # 0x73b730
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_stats_diag_8_dispatcher
parasail_result_t* parasail_sg_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_stats_diag_8_pointer = parasail_sg_stats_diag_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_stats_diag_8_pointer = parasail_sg_stats_diag_neon_128_8;
    }
    else
#endif
    {
        parasail_sg_stats_diag_8_pointer = parasail_sg;
    }
    return parasail_sg_stats_diag_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3278
leaq 0x2d4c43(%rip), %rax    # 0x487eb9
jmp 0x1b32a7
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b328c
leaq 0x1de893(%rip), %rax    # 0x391b1d
jmp 0x1b32a7
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b32a0
leaq 0x896c0(%rip), %rax     # 0x23c95e
jmp 0x1b32a7
leaq 0xd3e35(%rip), %rax     # 0x2870dc
movq %rax, 0x58848a(%rip)    # 0x73b738
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_scan_64_dispatcher
parasail_result_t* parasail_sg_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_table_scan_64_pointer = parasail_sg_table_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_64_pointer = parasail_sg_table_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_sg_table_scan_64_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b3301
leaq 0x2e654a(%rip), %rax    # 0x499849
jmp 0x1b3330
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b3315
leaq 0x1ee6d6(%rip), %rax    # 0x3a19e9
jmp 0x1b3330
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b3329
leaq 0x8a6a5(%rip), %rax     # 0x23d9cc
jmp 0x1b3330
leaq 0xe775d(%rip), %rax     # 0x29aa8d
movq %rax, 0x588409(%rip)    # 0x73b740
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sg_dispatch.c
// Function: parasail_sg_table_scan_32_dispatcher
parasail_result_t* parasail_sg_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_table_scan_32_pointer = parasail_sg_table_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_sg_table_scan_32_pointer = parasail_sg_table_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_sg_table_scan_32_pointer = parasail_sg_scan;
    }
    return parasail_sg_table_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5672cf
testl %eax, %eax
je 0x1b338a
leaq 0x2e8448(%rip), %rax    # 0x49b7d0
jmp 0x1b33b9
xorl %eax, %eax
callq 0x5672f6
testl %eax, %eax
je 0x1b339e
leaq 0x1f0320(%rip), %rax    # 0x3a36bc
jmp 0x1b33b9
xorl %eax, %eax
callq 0x56732c
testl %eax, %eax
jne 0x1b33b2
leaq 0x8a61c(%rip), %rax     # 0x23d9cc
jmp 0x1b33b9
leaq 0xe985d(%rip), %rax     # 0x29cc16
movq %rax, 0x588388(%rip)    # 0x73b748
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax