LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_stats_rowcol_diag_sse41_128_sat
parasail_result_t* parasail_sg_qb_stats_rowcol_diag_sse41_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_stats_rowcol_diag_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_stats_rowcol_diag_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_stats_rowcol_diag_sse41_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x48106b
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25a991
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x47bbc5
movq %rax, %rbx
jmp 0x25a996
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25a9d0
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4778d8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_stats_rowcol_diag_avx2_256_sat
parasail_result_t* parasail_sg_qb_stats_rowcol_diag_avx2_256_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_stats_rowcol_diag_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_stats_rowcol_diag_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_stats_rowcol_diag_avx2_256_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x593bdb
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25aa5b
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x58cc47
movq %rax, %rbx
jmp 0x25aa60
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25aa9a
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x587a05
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_scan_sat
parasail_result_t* parasail_sg_qb_trace_scan_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_scan_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_scan_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_scan_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x21f303
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25ab25
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x21f2fa
movq %rax, %rbx
jmp 0x25ab2a
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25ab64
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f2f1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_scan_sse41_128_sat
parasail_result_t* parasail_sg_qb_trace_scan_sse41_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_scan_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_scan_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_scan_sse41_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x498cbb
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25acb9
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x49698f
movq %rax, %rbx
jmp 0x25acbe
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25acf8
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x494a6f
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_scan_avx2_256_sat
parasail_result_t* parasail_sg_qb_trace_scan_avx2_256_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_scan_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_scan_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_scan_avx2_256_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x5af9f4
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25ad83
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x5ac553
movq %rax, %rbx
jmp 0x25ad88
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25adc2
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5a9e60
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_striped_sat
parasail_result_t* parasail_sg_qb_trace_striped_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_striped_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x21f327
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25ae4d
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x21f31e
movq %rax, %rbx
jmp 0x25ae52
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25ae8c
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f315
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_striped_sse2_128_sat
parasail_result_t* parasail_sg_qb_trace_striped_sse2_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_striped_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_sse2_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x3c0496
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25af17
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x3bd283
movq %rax, %rbx
jmp 0x25af1c
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25af56
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ba8dd
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_striped_sse41_128_sat
parasail_result_t* parasail_sg_qb_trace_striped_sse41_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_striped_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_sse41_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x4abbfc
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25afe1
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x4a930b
movq %rax, %rbx
jmp 0x25afe6
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b020
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4a6e29
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_striped_avx2_256_sat
parasail_result_t* parasail_sg_qb_trace_striped_avx2_256_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_striped_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_striped_avx2_256_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x5c82c1
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b0ab
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x5c485f
movq %rax, %rbx
jmp 0x25b0b0
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b0ea
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5c1c07
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_diag_sat
parasail_result_t* parasail_sg_qb_trace_diag_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_diag_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_diag_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_diag_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x21f34b
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b175
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x21f342
movq %rax, %rbx
jmp 0x25b17a
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b1b4
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f339
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_diag_sse2_128_sat
parasail_result_t* parasail_sg_qb_trace_diag_sse2_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_diag_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_diag_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_diag_sse2_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x3b4992
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b23f
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x3b0f64
movq %rax, %rbx
jmp 0x25b244
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b27e
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ae8c3
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qb_trace_diag_avx2_256_sat
parasail_result_t* parasail_sg_qb_trace_diag_avx2_256_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qb_trace_diag_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_diag_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qb_trace_diag_avx2_256_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x5bc701
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b3d3
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x5b7692
movq %rax, %rbx
jmp 0x25b3d8
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b412
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5b40e2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_scan_sat
parasail_result_t* parasail_sg_qe_scan_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_scan_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_scan_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_scan_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x223d0b
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b49d
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x223d02
movq %rax, %rbx
jmp 0x25b4a2
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b4dc
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x223cf9
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_scan_sse2_128_sat
parasail_result_t* parasail_sg_qe_scan_sse2_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_scan_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_scan_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_scan_sse2_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x2b5e02
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b567
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x2b3478
movq %rax, %rbx
jmp 0x25b56c
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b5a6
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b13a1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_scan_sse41_128_sat
parasail_result_t* parasail_sg_qe_scan_sse41_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_scan_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_scan_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_scan_sse41_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x3c781d
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b631
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x3c5818
movq %rax, %rbx
jmp 0x25b636
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b670
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c3c39
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_striped_sat
parasail_result_t* parasail_sg_qe_striped_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_striped_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x223d2f
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b7c5
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x223d26
movq %rax, %rbx
jmp 0x25b7ca
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b804
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x223d1d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_striped_sse2_128_sat
parasail_result_t* parasail_sg_qe_striped_sse2_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_striped_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_sse2_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x2c67fc
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b88f
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x2c41fa
movq %rax, %rbx
jmp 0x25b894
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b8ce
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c2479
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_striped_sse41_128_sat
parasail_result_t* parasail_sg_qe_striped_sse41_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_striped_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_sse41_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x3d5538
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25b959
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x3d37cc
movq %rax, %rbx
jmp 0x25b95e
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25b998
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d1e63
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_striped_avx2_256_sat
parasail_result_t* parasail_sg_qe_striped_avx2_256_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_striped_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_striped_avx2_256_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x4c586c
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25ba23
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x4c2943
movq %rax, %rbx
jmp 0x25ba28
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25ba62
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4c083c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_diag_sat
parasail_result_t* parasail_sg_qe_diag_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_diag_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x223d53
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25baed
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x223d4a
movq %rax, %rbx
jmp 0x25baf2
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25bb2c
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x223d41
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_diag_sse2_128_sat
parasail_result_t* parasail_sg_qe_diag_sse2_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_diag_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_sse2_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x2be411
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25bbb7
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x2bba55
movq %rax, %rbx
jmp 0x25bbbc
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25bbf6
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b9bd5
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_diag_sse41_128_sat
parasail_result_t* parasail_sg_qe_diag_sse41_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_diag_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_sse41_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x3ce9b2
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25bc81
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x3cc637
movq %rax, %rbx
jmp 0x25bc86
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25bcc0
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3caa67
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_diag_avx2_256_sat
parasail_result_t* parasail_sg_qe_diag_avx2_256_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_diag_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_diag_avx2_256_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x4bd2e2
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25bd4b
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x4ba38d
movq %rax, %rbx
jmp 0x25bd50
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25bd8a
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b7f27
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_stats_scan_sat
parasail_result_t* parasail_sg_qe_stats_scan_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_stats_scan_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_stats_scan_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_stats_scan_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x223d77
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25be15
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x223d6e
movq %rax, %rbx
jmp 0x25be1a
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25be54
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x223d65
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_qe_stats_scan_sse2_128_sat
parasail_result_t* parasail_sg_qe_stats_scan_sse2_128_sat(
        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)
{
    parasail_result_t * result = NULL;

    result = parasail_sg_qe_stats_scan_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_stats_scan_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_qe_stats_scan_sse2_128_32(s1, s1Len, s2, s2Len, open, gap, matrix);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rsp)
movl %r9d, 0x14(%rsp)
callq 0x2d570b
movq %rax, %rbx
movq %rax, %rdi
callq 0x20be2e
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x25bedf
movq %rbx, %rdi
callq 0x20afbc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl 0x14(%rsp), %r14d
movl %r14d, %r9d
callq 0x2d1188
movq %rax, %rbx
jmp 0x25bee4
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x20be2e
testl %eax, %eax
je 0x25bf1e
movq %rbx, %rdi
callq 0x20afbc
movq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r12d, %ecx
movl %r15d, %r8d
movl %r14d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2cd556
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq