LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_nw_trace_diag_sse2_128_sat
parasail_result_t* parasail_nw_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_nw_trace_diag_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_nw_trace_diag_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_nw_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 0x35121c
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f01c3
movq %rbx, %rdi
callq 0x1abdad
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 0x34e54c
movq %rax, %rbx
jmp 0x1f01c8
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0202
movq %rbx, %rdi
callq 0x1abdad
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 0x34c240
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_nw_trace_diag_sse41_128_sat
parasail_result_t* parasail_nw_trace_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_nw_trace_diag_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_nw_trace_diag_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_nw_trace_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 0x445750
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f028d
movq %rbx, %rdi
callq 0x1abdad
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 0x442b58
movq %rax, %rbx
jmp 0x1f0292
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f02cc
movq %rbx, %rdi
callq 0x1abdad
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 0x440a84
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_nw_trace_diag_avx2_256_sat
parasail_result_t* parasail_nw_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_nw_trace_diag_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_nw_trace_diag_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_nw_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 0x556c70
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0357
movq %rbx, %rdi
callq 0x1abdad
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 0x552c34
movq %rax, %rbx
jmp 0x1f035c
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0396
movq %rbx, %rdi
callq 0x1abdad
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 0x5500f4
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_scan_sat
parasail_result_t* parasail_sg_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_scan_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_scan_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x1b6db7
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0421
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6dae
movq %rax, %rbx
jmp 0x1f0426
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0460
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6da5
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_scan_sse2_128_sat
parasail_result_t* parasail_sg_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_scan_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_scan_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x256cda
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f04eb
movq %rbx, %rdi
callq 0x1abdad
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 0x254e49
movq %rax, %rbx
jmp 0x1f04f0
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f052a
movq %rbx, %rdi
callq 0x1abdad
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 0x25314d
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_scan_sse41_128_sat
parasail_result_t* parasail_sg_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_scan_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_scan_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x367463
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f05b5
movq %rbx, %rdi
callq 0x1abdad
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 0x3658cf
movq %rax, %rbx
jmp 0x1f05ba
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f05f4
movq %rbx, %rdi
callq 0x1abdad
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 0x363d44
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_scan_avx2_256_sat
parasail_result_t* parasail_sg_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_scan_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_scan_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x45a1ea
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f067f
movq %rbx, %rdi
callq 0x1abdad
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 0x45867d
movq %rax, %rbx
jmp 0x1f0684
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f06be
movq %rbx, %rdi
callq 0x1abdad
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 0x456b01
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_striped_sat
parasail_result_t* parasail_sg_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_striped_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_striped_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x1b6ddb
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0749
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6dd2
movq %rax, %rbx
jmp 0x1f074e
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0788
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6dc9
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_striped_sse2_128_sat
parasail_result_t* parasail_sg_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_striped_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_striped_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x267b83
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0813
movq %rbx, %rdi
callq 0x1abdad
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 0x265f1f
movq %rax, %rbx
jmp 0x1f0818
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0852
movq %rbx, %rdi
callq 0x1abdad
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 0x2644b4
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_diag_sat
parasail_result_t* parasail_sg_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_diag_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_diag_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x1b6dff
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0a71
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6df6
movq %rax, %rbx
jmp 0x1f0a76
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0ab0
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6ded
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_diag_sse2_128_sat
parasail_result_t* parasail_sg_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_diag_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_diag_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x25fd31
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0b3b
movq %rbx, %rdi
callq 0x1abdad
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 0x25d0fc
movq %rax, %rbx
jmp 0x1f0b40
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0b7a
movq %rbx, %rdi
callq 0x1abdad
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 0x25b0f3
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_diag_sse41_128_sat
parasail_result_t* parasail_sg_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_diag_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_diag_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x36eec2
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0c05
movq %rbx, %rdi
callq 0x1abdad
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 0x36ca58
movq %rax, %rbx
jmp 0x1f0c0a
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0c44
movq %rbx, %rdi
callq 0x1abdad
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 0x36ad71
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_diag_avx2_256_sat
parasail_result_t* parasail_sg_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_diag_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_diag_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x4637f5
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0ccf
movq %rbx, %rdi
callq 0x1abdad
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 0x46075f
movq %rax, %rbx
jmp 0x1f0cd4
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0d0e
movq %rbx, %rdi
callq 0x1abdad
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 0x45e1f6
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_scan_sat
parasail_result_t* parasail_sg_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_stats_scan_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_scan_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_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 0x1b6e23
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0d99
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e1a
movq %rax, %rbx
jmp 0x1f0d9e
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0dd8
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e11
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_scan_sse2_128_sat
parasail_result_t* parasail_sg_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_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_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_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 0x276a46
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0e63
movq %rbx, %rdi
callq 0x1abdad
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 0x2730e7
movq %rax, %rbx
jmp 0x1f0e68
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f0ea2
movq %rbx, %rdi
callq 0x1abdad
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 0x26f916
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_scan_avx2_256_sat
parasail_result_t* parasail_sg_stats_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_stats_scan_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_scan_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x47803b
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f0ff7
movq %rbx, %rdi
callq 0x1abdad
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 0x474d07
movq %rax, %rbx
jmp 0x1f0ffc
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f1036
movq %rbx, %rdi
callq 0x1abdad
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 0x4719d6
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_striped_sat
parasail_result_t* parasail_sg_stats_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_stats_striped_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_striped_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x1b6e47
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f10c1
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e3e
movq %rax, %rbx
jmp 0x1f10c6
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f1100
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e35
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_striped_sse2_128_sat
parasail_result_t* parasail_sg_stats_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_stats_striped_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_striped_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x2967c8
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f118b
movq %rbx, %rdi
callq 0x1abdad
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 0x292f86
movq %rax, %rbx
jmp 0x1f1190
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f11ca
movq %rbx, %rdi
callq 0x1abdad
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 0x28f98a
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_striped_sse41_128_sat
parasail_result_t* parasail_sg_stats_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_stats_striped_sse41_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_striped_sse41_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x39f2c9
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f1255
movq %rbx, %rdi
callq 0x1abdad
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 0x39bff1
movq %rax, %rbx
jmp 0x1f125a
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f1294
movq %rbx, %rdi
callq 0x1abdad
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 0x398d65
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_striped_avx2_256_sat
parasail_result_t* parasail_sg_stats_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_stats_striped_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_striped_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x495804
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f131f
movq %rbx, %rdi
callq 0x1abdad
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 0x4925d7
movq %rax, %rbx
jmp 0x1f1324
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f135e
movq %rbx, %rdi
callq 0x1abdad
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 0x48f49c
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_diag_sat
parasail_result_t* parasail_sg_stats_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_stats_diag_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_diag_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x1b6e6b
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f13e9
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e62
movq %rax, %rbx
jmp 0x1f13ee
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f1428
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e59
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_diag_sse2_128_sat
parasail_result_t* parasail_sg_stats_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_stats_diag_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_diag_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x2870dc
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f14b3
movq %rbx, %rdi
callq 0x1abdad
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 0x28252c
movq %rax, %rbx
jmp 0x1f14b8
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f14f2
movq %rbx, %rdi
callq 0x1abdad
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 0x27eaa0
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_stats_diag_avx2_256_sat
parasail_result_t* parasail_sg_stats_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_stats_diag_avx2_256_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_diag_avx2_256_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_stats_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 0x487eb9
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f1647
movq %rbx, %rdi
callq 0x1abdad
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 0x48308d
movq %rax, %rbx
jmp 0x1f164c
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f1686
movq %rbx, %rdi
callq 0x1abdad
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 0x47f128
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_table_scan_sat
parasail_result_t* parasail_sg_table_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_table_scan_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_table_scan_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_table_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 0x1b6e8f
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f1711
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e86
movq %rax, %rbx
jmp 0x1f1716
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f1750
movq %rbx, %rdi
callq 0x1abdad
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 0x1b6e7d
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_O2/nh13[P]ksw/src/parasail/src/satcheck.c
// Function: parasail_sg_table_scan_sse2_128_sat
parasail_result_t* parasail_sg_table_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_table_scan_sse2_128_8(s1, s1Len, s2, s2Len, open, gap, matrix);
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_table_scan_sse2_128_16(s1, s1Len, s2, s2Len, open, gap, matrix);
    }
    if (parasail_result_is_saturated(result)) {
        parasail_result_free(result);
        result = parasail_sg_table_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 0x2a11c6
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ace42
testl %eax, %eax
movq %r14, 0x20(%rsp)
je 0x1f17db
movq %rbx, %rdi
callq 0x1abdad
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 0x29ec1e
movq %rax, %rbx
jmp 0x1f17e0
movl 0x14(%rsp), %r14d
movq %rbx, %rdi
callq 0x1ace42
testl %eax, %eax
je 0x1f181a
movq %rbx, %rdi
callq 0x1abdad
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 0x29cc16
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq