LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: CTEST_LOG
void CTEST_LOG(const char* fmt, ...)
{
    va_list argp;
    msg_start(ANSI_BLUE, "LOG");

    va_start(argp, fmt);
    vprint_errormsg(fmt, argp);
    va_end(argp);

    msg_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2365
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x3c88(%rip), %rdi      # 0x601b
leaq 0x3c89(%rip), %rsi      # 0x6023
callq 0x23e0
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2430
callq 0x24e0
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: vprint_errormsg
static void vprint_errormsg(const char* const fmt, va_list ap) {
    // (v)snprintf returns the number that would have been written
    const int ret = vsnprintf(ctest_errormsg, ctest_errorsize, fmt, ap);
    if (ret < 0) {
        ctest_errormsg[0] = 0x00;
    } else {
        const size_t size = (size_t) ret;
        const size_t s = (ctest_errorsize <= size ? size -ctest_errorsize : size);
        // ctest_errorsize may overflow at this point
        ctest_errorsize -= s;
        ctest_errormsg += s;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x8181(%rip), %rdi      # 0xa5c8
movq 0x8172(%rip), %rsi      # 0xa5c0
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x2090
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x2470
movq 0x815d(%rip), %rax      # 0xa5c8
movb $0x0, (%rax)
jmp 0x24cd
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8141(%rip), %rax      # 0xa5c0
cmpq -0x20(%rbp), %rax
ja 0x2496
movq -0x20(%rbp), %rax
subq 0x8130(%rip), %rax      # 0xa5c0
movq %rax, -0x30(%rbp)
jmp 0x249e
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq 0x810f(%rip), %rax      # 0xa5c0
subq %rcx, %rax
movq %rax, 0x8105(%rip)      # 0xa5c0
movq -0x28(%rbp), %rax
addq 0x8102(%rip), %rax      # 0xa5c8
movq %rax, 0x80fb(%rip)      # 0xa5c8
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: CTEST_ERR
void CTEST_ERR(const char* fmt, ...)
{
    va_list argp;
    msg_start(ANSI_YELLOW, "ERR");

    va_start(argp, fmt);
    vprint_errormsg(fmt, argp);
    va_end(argp);

    msg_end();
    longjmp(ctest_err, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2545
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x3ab4(%rip), %rdi      # 0x6027
leaq 0x3ab5(%rip), %rsi      # 0x602f
callq 0x23e0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2430
leaq -0x20(%rbp), %rax
callq 0x24e0
leaq 0x6f10(%rip), %rdi      # 0x94d0
movl $0x1, %esi
callq 0x21f0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_str
void assert_str(const char* exp, const char*  real, const char* caller, int line) {
    if ((exp == NULL && real != NULL) ||
        (exp != NULL && real == NULL) ||
        (exp && real && strcmp(exp, real) != 0)) {
        CTEST_ERR("%s:%d  expected '%s', got '%s'", caller, line, exp, real);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x25f5
cmpq $0x0, -0x10(%rbp)
jne 0x2623
cmpq $0x0, -0x8(%rbp)
je 0x2603
cmpq $0x0, -0x10(%rbp)
je 0x2623
cmpq $0x0, -0x8(%rbp)
je 0x2640
cmpq $0x0, -0x10(%rbp)
je 0x2640
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
je 0x2640
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0x39fa(%rip), %rdi      # 0x6033
movb $0x0, %al
callq 0x2510
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_wstr
void assert_wstr(const wchar_t *exp, const wchar_t *real, const char* caller, int line) {
    if ((exp == NULL && real != NULL) ||
        (exp != NULL && real == NULL) ||
        (exp && real && wcscmp(exp, real) != 0)) {
        CTEST_ERR("%s:%d  expected '%ls', got '%ls'", caller, line, exp, real);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2675
cmpq $0x0, -0x10(%rbp)
jne 0x26a3
cmpq $0x0, -0x8(%rbp)
je 0x2683
cmpq $0x0, -0x10(%rbp)
je 0x26a3
cmpq $0x0, -0x8(%rbp)
je 0x26c0
cmpq $0x0, -0x10(%rbp)
je 0x26c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2040
cmpl $0x0, %eax
je 0x26c0
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0x3999(%rip), %rdi      # 0x6052
movb $0x0, %al
callq 0x2510
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_data
void assert_data(const unsigned char* exp, size_t expsize,
                 const unsigned char* real, size_t realsize,
                 const char* caller, int line) {
    size_t i;
    if (expsize != realsize) {
        CTEST_ERR("%s:%d  expected %" PRIuMAX " bytes, got %" PRIuMAX, caller, line, (uintmax_t) expsize, (uintmax_t) realsize);
    }
    for (i=0; i<expsize; i++) {
        if (exp[i] != real[i]) {
            CTEST_ERR("%s:%d expected 0x%02x at offset %" PRIuMAX " got 0x%02x",
                caller, line, exp[i], (uintmax_t) i, real[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x2717
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x3963(%rip), %rdi      # 0x6073
movb $0x0, %al
callq 0x2510
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2787
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2777
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x38(%rbp), %r8
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rdi
movzbl (%rax,%rdi), %r9d
leaq 0x3926(%rip), %rdi      # 0x6096
movb $0x0, %al
callq 0x2510
jmp 0x2779
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x271f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_dbl_near
void assert_dbl_near(double exp, double real, double tol, const char* caller, int line) {
    double diff = exp - real;
    double absdiff = diff;
    /* avoid using fabs and linking with a math lib */
    if(diff < 0) {
      absdiff *= -1;
    }
    if (absdiff > tol) {
        CTEST_ERR("%s:%d  expected %0.3e, got %0.3e (diff %0.3e, tol %0.3e)", caller, line, exp, real, diff, tol);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x2963
movsd 0x36af(%rip), %xmm0     # 0x6008
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x2998
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x18(%rbp), %xmm3
leaq 0x37c1(%rip), %rdi      # 0x6152
movb $0x4, %al
callq 0x2510
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_dbl_far
void assert_dbl_far(double exp, double real, double tol, const char* caller, int line) {
    double diff = exp - real;
    double absdiff = diff;
    /* avoid using fabs and linking with a math lib */
    if(diff < 0) {
      absdiff *= -1;
    }
    if (absdiff <= tol) {
        CTEST_ERR("%s:%d  expected %0.3e, got %0.3e (diff %0.3e, tol %0.3e)", caller, line, exp, real, diff, tol);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x29f3
movsd 0x361f(%rip), %xmm0     # 0x6008
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x2a2c
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x18(%rbp), %xmm3
leaq 0x372d(%rip), %rdi      # 0x6152
movb $0x4, %al
callq 0x2510
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: getCurrentTime
static uint64_t getCurrentTime(void) {
    struct timeval now;
    gettimeofday(&now, NULL);
    uint64_t now64 = (uint64_t) now.tv_sec;
    now64 *= 1000000;
    now64 += ((uint64_t) now.tv_usec);
    return now64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2120
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
imulq $0xf4240, -0x18(%rbp), %rax # imm = 0xF4240
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/thirdparty/ctest.h
// Function: color_print
static void color_print(const char* color, const char* text) {
    if (color_output)
        printf("%s%s"ANSI_NORMAL"\n", color, text);
    else
        printf("%s\n", text);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x6119(%rip)      # 0x9130
je 0x3031
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x3264(%rip), %rdi      # 0x628c
movb $0x0, %al
callq 0x20f0
jmp 0x3043
movq -0x10(%rbp), %rsi
leaq 0x3ac9(%rip), %rdi      # 0x6b05
movb $0x0, %al
callq 0x20f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/utilities.c
// Function: Escape_html
char* Escape_html(char* str)
{
    int len = (int)strlen(str);
    /// In the worst case, string is increased 3 times + '\0'
    char* without_html_str = (char*)calloc((len * 3) + 1, sizeof(char));
    int j = 0;
    for (int i = 0; i < len; i++, j++) {
        if (str[i] == '<') {
            without_html_str[j] = '&';
            without_html_str[j + 1] = 'l';
            without_html_str[j + 2] = 't';
            j += 2;
        } else if (str[i] == '>') {
            without_html_str[j] = '&';
            without_html_str[j + 1] = 'g';
            without_html_str[j + 2] = 't';
            j += 2;
        } else {
            without_html_str[j] = str[i];
        }
    }
    without_html_str[j] = '\0';
    free(str);
    return without_html_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movl %eax, -0xc(%rbp)
imull $0x3, -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x463f
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x45c4
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x26, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x6c, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb $0x74, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4626
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3e, %eax
jne 0x460e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x26, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x67, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb $0x74, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4624
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4626
jmp 0x4628
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x456e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/utilities.c
// Function: Get_filename_without_extension
const char* Get_filename_without_extension(char* path)
{
    char* temp_path = (char*)calloc(strlen(path), sizeof(char*));
    strcpy(temp_path, path);
    char* last_dot_ptr = strrchr(path, '.');
    if (last_dot_ptr == NULL) {
        return "";
    }
    int last_dot_index = last_dot_ptr - path;
    temp_path[last_dot_index] = '\0';
    temp_path = strrchr(temp_path, '/');
    return temp_path == NULL ? "" : temp_path + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
movl $0x8, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x2110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x46b9
leaq 0x248a(%rip), %rax      # 0x6b3d
movq %rax, -0x8(%rbp)
jmp 0x470d
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x2110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x46f9
leaq 0x244a(%rip), %rax      # 0x6b3d
movq %rax, -0x30(%rbp)
jmp 0x4705
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/utilities.c
// Function: Search_files_recursive
int Search_files_recursive(char* path, char** paths, int* recursive_exit_flag)
{
    DIR* d = opendir(path);
    if (d == NULL) {
        printf("\x1b[31m Error! \x1b[0m Wrong path\n");
        return 0;
    }
    struct dirent* dir;
    while ((dir = readdir(d)) != NULL) {
        /// Hidden and system files check
        if (dir->d_name[0] == '.') {
            continue;
        }
        if (*recursive_exit_flag == MAX_COUNT_OF_FILES) {
            return -1;
        }
        if (dir->d_type != DT_DIR) {
            char* f_path = (char*)calloc(MAX_PATH_LEN, sizeof(char));
            sprintf(f_path, "%s/%s", path, dir->d_name);
            strcpy(paths[*recursive_exit_flag], f_path);
            free(f_path);
            *recursive_exit_flag = *recursive_exit_flag + 1;
        } else if (
                dir->d_type == DT_DIR && strcmp(dir->d_name, ".") != 0
                && strcmp(dir->d_name, "..") != 0) {
            char d_path[MAX_PATH_LEN * 2];
            sprintf(d_path, "%s/%s", path, dir->d_name);
            Search_files_recursive(d_path, paths, recursive_exit_flag);
        }
    }
    closedir(d);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4765
leaq 0x2302(%rip), %rdi      # 0x6a54
movb $0x0, %al
callq 0x20f0
movl $0x0, -0x4(%rbp)
jmp 0x489d
jmp 0x4767
movq -0x28(%rbp), %rdi
callq 0x21d0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x488d
movq -0x30(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
jne 0x478d
jmp 0x4767
movq -0x20(%rbp), %rax
cmpl $0x1e, (%rax)
jne 0x47a2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x489d
movq -0x30(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
je 0x4812
movl $0xff, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rcx
addq $0x13, %rcx
leaq 0x2299(%rip), %rsi      # 0x6a72
movb $0x0, %al
callq 0x2210
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x38(%rbp), %rsi
callq 0x2070
movq -0x38(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x4888
movq -0x30(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x4886
movq -0x30(%rbp), %rdi
addq $0x13, %rdi
leaq 0x224b(%rip), %rsi      # 0x6a79
callq 0x2190
cmpl $0x0, %eax
je 0x4886
movq -0x30(%rbp), %rdi
addq $0x13, %rdi
leaq 0x2231(%rip), %rsi      # 0x6a78
callq 0x2190
cmpl $0x0, %eax
je 0x4886
leaq -0x240(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rcx
addq $0x13, %rcx
leaq 0x2207(%rip), %rsi      # 0x6a72
movb $0x0, %al
callq 0x2210
leaq -0x240(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4720
jmp 0x4888
jmp 0x4767
movq -0x28(%rbp), %rdi
callq 0x2150
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/utilities.c
// Function: Get_data_from_document
char** Get_data_from_document(char* paths)
{
    FILE* myfile;
    myfile = fopen(paths, "r");
    if (myfile == NULL) {
        printf("%s%s%s\n", "On path ", paths, " file not found!");
        return 0;
    }
    char* ptrFile;
    int quan_str = 0;
    char** data = (char**)calloc(MAX_QTY_STR, sizeof(char*));
    for (int i = 0; i < MAX_QTY_STR; i++) {
        data[i] = (char*)calloc(MAX_LEN_INP_STR, sizeof(char));
    }
    while (quan_str < MAX_QTY_STR) {
        char* temp = (char*)calloc(MAX_LEN_INP_STR, sizeof(char));
        ptrFile = fgets(temp, MAX_LEN_INP_STR, myfile);
        if (ptrFile == NULL) {
            if (feof(myfile) != 0) {
                break;
            }
        }
        strcpy(data[quan_str], temp);
        quan_str++;
        free(temp);
    }
    fclose(myfile);
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x22a8(%rip), %rsi      # 0x6b6f
callq 0x2200
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4904
movq -0x10(%rbp), %rdx
leaq 0x2199(%rip), %rdi      # 0x6a7b
leaq 0x219a(%rip), %rsi      # 0x6a83
leaq 0x219c(%rip), %rcx      # 0x6a8c
movb $0x0, %al
callq 0x20f0
movq $0x0, -0x8(%rbp)
jmp 0x49de
movl $0x0, -0x24(%rbp)
movl $0xc350, %edi           # imm = 0xC350
movl $0x8, %esi
callq 0x2180
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0xc350, -0x34(%rbp)    # imm = 0xC350
jge 0x4957
movl $0x1f4, %edi            # imm = 0x1F4
movl $0x1, %esi
callq 0x2180
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4925
jmp 0x4959
cmpl $0xc350, -0x24(%rbp)    # imm = 0xC350
jge 0x49cd
movl $0x1f4, %edi            # imm = 0x1F4
movl $0x1, %esi
callq 0x2180
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x2160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x49a4
movq -0x18(%rbp), %rdi
callq 0x21a0
cmpl $0x0, %eax
je 0x49a2
jmp 0x49cd
jmp 0x49a4
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x40(%rbp), %rsi
callq 0x2070
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2030
jmp 0x4959
movq -0x18(%rbp), %rdi
callq 0x20a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/utilities.c
// Function: Print_help
void Print_help()
{
    printf("%s\n%s\n",
           "usage: documentary [--version] [--help]",
           "\t  [-inpdir <path>] [-outdir <path>]");
    printf("%s\n", "Available commands");
    printf("\t%s\n", "-inpdir");
    printf("\t%s\n", "-outdir");
    printf("\t%s\n", "--help");
    printf("\t%s\n", "--version");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2052(%rip), %rdi      # 0x6a9d
leaq 0x2052(%rip), %rsi      # 0x6aa4
leaq 0x2073(%rip), %rdx      # 0x6acc
movb $0x0, %al
callq 0x20f0
leaq 0x209e(%rip), %rdi      # 0x6b05
leaq 0x2083(%rip), %rsi      # 0x6af1
movb $0x0, %al
callq 0x20f0
leaq 0x2088(%rip), %rdi      # 0x6b04
leaq 0x185b(%rip), %rsi      # 0x62de
movb $0x0, %al
callq 0x20f0
leaq 0x2073(%rip), %rdi      # 0x6b04
leaq 0x1854(%rip), %rsi      # 0x62ec
movb $0x0, %al
callq 0x20f0
leaq 0x205e(%rip), %rdi      # 0x6b04
leaq 0x1870(%rip), %rsi      # 0x631d
movb $0x0, %al
callq 0x20f0
leaq 0x2049(%rip), %rdi      # 0x6b04
leaq 0x1851(%rip), %rsi      # 0x6313
movb $0x0, %al
callq 0x20f0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/utilities.c
// Function: Check_argc
int Check_argc(int argc, char** array_argv)
{
    if (argc == 1) {
        printf("%s\n%s\n",
               "usage: documentary [--version] [--help]",
               "\t  [-inpdir <path>] [-outdir <path>]");
        return 0;
    }
    if (argc > 5 || argc == 4) {
        printf("Error! Invalid number of arguments");
        return 0;
    }
    if (argc == 2) {
        if (strcmp(array_argv[1], HELP_FLAG) == 0) {
            Print_help();
            return 0;
        }
        if (strcmp(array_argv[1], VERSION_FLAG) == 0) {
            printf("%s\n", PROGRAM_VERSION);
            return 0;
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x4b0d
leaq 0x1fb1(%rip), %rdi      # 0x6a9d
leaq 0x1fb1(%rip), %rsi      # 0x6aa4
leaq 0x1fd2(%rip), %rdx      # 0x6acc
movb $0x0, %al
callq 0x20f0
movl $0x0, -0x4(%rbp)
jmp 0x4b9d
cmpl $0x5, -0x8(%rbp)
jg 0x4b19
cmpl $0x4, -0x8(%rbp)
jne 0x4b30
leaq 0x1fe9(%rip), %rdi      # 0x6b09
movb $0x0, %al
callq 0x20f0
movl $0x0, -0x4(%rbp)
jmp 0x4b9d
cmpl $0x2, -0x8(%rbp)
jne 0x4b96
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x17d8(%rip), %rsi      # 0x631d
callq 0x2190
cmpl $0x0, %eax
jne 0x4b5d
callq 0x4a40
movl $0x0, -0x4(%rbp)
jmp 0x4b9d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x17a7(%rip), %rsi      # 0x6313
callq 0x2190
cmpl $0x0, %eax
jne 0x4b94
leaq 0x1f88(%rip), %rdi      # 0x6b05
leaq 0x1fa8(%rip), %rsi      # 0x6b2c
movb $0x0, %al
callq 0x20f0
movl $0x0, -0x4(%rbp)
jmp 0x4b9d
jmp 0x4b96
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/comments_check.c
// Function: Check_single_comment
int Check_single_comment(char* str)
{
    size_t len = strlen(str);
    for (unsigned int i = 0; i < len; i++) {
        if (str[i] == '/' && str[i + 1] == '/') {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0x4e34
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x4e27
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x4e27
movl $0x1, -0x4(%rbp)
jmp 0x4e3b
jmp 0x4e29
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4df0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_begin
char* Del_multiline_comment_begin(char* str)
{
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '/' && str[i + 1] == '*') {
            str[i] = ' ';
            str[i + 1] = ' ';
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5011
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x5004
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x5004
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
jmp 0x5006
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4faf
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_end
char* Del_multiline_comment_end(char* str)
{
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '*' && str[i + 1] == '/') {
            str[i] = ' ';
            str[i + 1] = ' ';
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5091
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x5084
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x5084
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
jmp 0x5086
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x502f
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_stars
char* Del_multiline_comment_stars(char* str)
{
    for (unsigned int i = 0; i < strlen(str); i++) {
        if (str[i] != ' ' && str[i] != '*') {
            break;
        } else if (str[i] != ' ' && str[i] == '*') {
            str[i] = ' ';
            break;
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x512d
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x50f1
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
je 0x50f1
jmp 0x512d
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x511e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x511e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x20, (%rax,%rcx)
jmp 0x512d
jmp 0x5120
jmp 0x5122
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x50b3
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/advanced_check.c
// Function: Check_extension
int Check_extension(char* path)
{
    char* valid_extentions[QTY_OF_EXTENSION] = {"cpp", "h", "c"};
    char* temp = Get_file_extension(path);
    for (int i = 0; i < QTY_OF_EXTENSION; i++) {
        if (strcmp(temp, valid_extentions[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq 0x3c7d(%rip), %rax      # 0x8dd0
movq %rax, -0x30(%rbp)
movq 0x3c7a(%rip), %rax      # 0x8dd8
movq %rax, -0x28(%rbp)
movq 0x3c77(%rip), %rax      # 0x8de0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49f0
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x51b4
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x51a7
movl $0x1, -0x4(%rbp)
jmp 0x51bb
jmp 0x51a9
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5181
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/advanced_check.c
// Function: Check_single_documentary_comment
int Check_single_documentary_comment(char* str)
{
    char* ptr_slash = strchr(str, '/');
    if (Check_single_comment(str) == 1) {
        if (ptr_slash[2] == '/' || ptr_slash[2] == '!') {
            return 1;
        } else {
            return 0;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dd0
cmpl $0x1, %eax
jne 0x5228
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x2f, %eax
je 0x5216
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x21, %eax
jne 0x521f
movl $0x1, -0x4(%rbp)
jmp 0x522f
movl $0x0, -0x4(%rbp)
jmp 0x522f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/advanced_check.c
// Function: Check_multiline_documentary_comment
int Check_multiline_documentary_comment(char* str)
{
    char* ptr_first_star = strchr(str, '*');
    if (Check_multiline_comment_begin(str) == 1) {
        if (ptr_first_star[1] == '*' || ptr_first_star[1] == '!') {
            return 1;
        } else {
            return 0;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e50
cmpl $0x1, %eax
jne 0x5298
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2a, %eax
je 0x5286
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x21, %eax
jne 0x528f
movl $0x1, -0x4(%rbp)
jmp 0x529f
movl $0x0, -0x4(%rbp)
jmp 0x529f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/advanced_handle.c
// Function: Generate_filename
char* Generate_filename(char* path, char* dest_dir)
{
    long int s_time = 0;
    struct tm* m_time;
    s_time = time(NULL);
    m_time = localtime(&s_time);
    char* str_time = asctime(m_time);
    for (int i = 0; str_time[i] != '\0'; i++) {
        if (str_time[i] == ' ') {
            str_time[i] = '_';
        }
    }
    size_t len = strlen(str_time) - 1;
    if (str_time[len] == '\n') {
        str_time[len] = '\0';
    }
    int max_time_len = 50;
    char* filename = (char*)calloc((strlen(path) + max_time_len), sizeof(char));
    sprintf(filename,
            "%s%s%s%s%s%s",
            dest_dir,
            "/",
            Get_filename_without_extension(path),
            "_",
            str_time,
            ".html");
    return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21c0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20d0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5331
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x5324
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
jmp 0x5326
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x52f6
movq -0x28(%rbp), %rdi
callq 0x20c0
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x535f
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x32, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4660
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %r8
movq -0x28(%rbp), %r10
leaq 0x1802(%rip), %rsi      # 0x6bb8
leaq 0x11df(%rip), %rcx      # 0x659c
leaq 0x1801(%rip), %r9       # 0x6bc5
leaq 0x18df(%rip), %rax      # 0x6caa
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2210
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/advanced_handle.c
// Function: Get_document_type
char* Get_document_type(char* path)
{
    char* extension = Get_file_extension(path);
    if (!strcmp(extension, "h")) {
        return "<i>Header file to program code on C/C++</i></br></br>";
    } else if (!strcmp(extension, "c")) {
        return "<i>Program code in language C</i></br></br>";
    } else if (!strcmp(extension, "cpp")) {
        return "<i>Program code in language C++</i></br></br>";
    }
    return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x13eb(%rip), %rsi      # 0x67ff
callq 0x2190
cmpl $0x0, %eax
jne 0x542b
leaq 0x17a2(%rip), %rax      # 0x6bc7
movq %rax, -0x8(%rbp)
jmp 0x547e
movq -0x18(%rbp), %rdi
leaq 0x148d(%rip), %rsi      # 0x68c3
callq 0x2190
cmpl $0x0, %eax
jne 0x544d
leaq 0x17b6(%rip), %rax      # 0x6bfd
movq %rax, -0x8(%rbp)
jmp 0x547e
movq -0x18(%rbp), %rdi
leaq 0xed7(%rip), %rsi       # 0x632f
callq 0x2190
cmpl $0x0, %eax
jne 0x546f
leaq 0x17c0(%rip), %rax      # 0x6c29
movq %rax, -0x8(%rbp)
jmp 0x547e
jmp 0x5471
jmp 0x5473
leaq 0x16c3(%rip), %rax      # 0x6b3d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/morozov312[P]documentary/./src/processing.c
// Function: Check_code
int Check_code(char* str)
{
    int single_flag = Check_single_comment(str);
    int multiline_begin_flag = Check_multiline_comment_begin(str);
    int multiline_end_flag = Check_multiline_comment_end(str);
    if (!single_flag && !multiline_begin_flag && !multiline_end_flag) {
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4dd0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e50
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ed0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x574b
cmpl $0x0, -0x18(%rbp)
jne 0x574b
cmpl $0x0, -0x1c(%rbp)
jne 0x574b
movl $0x1, -0x4(%rbp)
jmp 0x5752
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/refcount/refcount.c
// Function: allocate
struct node *allocate()
{
  /* A node is alloctaed with a refcount of 0, so the
     client program is responsible for immediately
     incrementing the reference count. */
  struct rc_node *rn = raw_malloc(sizeof(struct rc_node));
  rn->count = 0;
  rn->n.left = NULL;
  rn->n.right = NULL;
  return &rn->n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x13d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x8, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/refcount/refcount.c
// Function: refcount_dec
void refcount_dec(struct node *p)
{
  if (p) {
    /* Decrement the reference count, and free if it does to zero */
    struct rc_node *rn = NODE_TO_RC(p);
    if (--rn->count == 0) {
      refcount_dec(rn->n.left);
      refcount_dec(rn->n.right);
      raw_free(rn, sizeof(struct rc_node));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1529
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x1527
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x14d0
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x1420
jmp 0x1529
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/evm.c
// Function: test_stop
void test_stop() {
    evmInit();

    address_t from = AddressFromHex42("0x4a6f6B9fF1fc974096f9063a45Fd12bD5B928AD1");
    uint64_t gas = 53006;
    val_t value;
    data_t input;

    op_t program[] = {
        STOP,
    };

    input.size = sizeof(program);
    input.content = program;

    result_t result = txCreate(from, gas, value, input);
    evmFinalize();
    assert(UPPER(UPPER(result.status)) == 0);
    assert(LOWER(UPPER(result.status)) == 0x80d9b122);
    assert(UPPER(LOWER(result.status)) == 0xdc3a16fdc41f96cf);
    assert(LOWER(LOWER(result.status)) == 0x010ffe7e38d227c3);
    assert(result.returnData.size == 0);
    assert(result.gasRemaining == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb $0x0, %al
callq 0xcfc0
leaq -0x18(%rbp), %rdi
leaq 0x17e07(%rip), %rsi     # 0x1b004
addq $0x2, %rsi
callq 0x3380
movq $0xcf0e, -0x20(%rbp)    # imm = 0xCF0E
leaq -0x41(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x3060
movq $0x1, -0x40(%rbp)
leaq -0x41(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq -0x88(%rbp), %rdi
leaq -0x18(%rbp), %rax
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0xe270
movb $0x0, %al
callq 0xd4d0
cmpq $0x0, -0x78(%rbp)
jne 0x3275
jmp 0x3294
leaq 0x17db3(%rip), %rdi     # 0x1b02f
leaq 0x17dcd(%rip), %rsi     # 0x1b050
movl $0x1b, %edx
leaq 0x17dcb(%rip), %rcx     # 0x1b05a
callq 0x3040
movl $0x80d9b122, %eax       # imm = 0x80D9B122
cmpq %rax, -0x70(%rbp)
jne 0x32a1
jmp 0x32c0
leaq 0x17dc3(%rip), %rdi     # 0x1b06b
leaq 0x17da1(%rip), %rsi     # 0x1b050
movl $0x1c, %edx
leaq 0x17d9f(%rip), %rcx     # 0x1b05a
callq 0x3040
movabsq $-0x23c5e9023be06931, %rax # imm = 0xDC3A16FDC41F96CF
cmpq %rax, -0x68(%rbp)
jne 0x32d2
jmp 0x32f1
leaq 0x17dbc(%rip), %rdi     # 0x1b095
leaq 0x17d70(%rip), %rsi     # 0x1b050
movl $0x1d, %edx
leaq 0x17d6e(%rip), %rcx     # 0x1b05a
callq 0x3040
movabsq $0x10ffe7e38d227c3, %rax # imm = 0x10FFE7E38D227C3
cmpq %rax, -0x60(%rbp)
jne 0x3303
jmp 0x3322
leaq 0x17dbd(%rip), %rdi     # 0x1b0c7
leaq 0x17d3f(%rip), %rsi     # 0x1b050
movl $0x1e, %edx
leaq 0x17d3d(%rip), %rcx     # 0x1b05a
callq 0x3040
cmpq $0x0, -0x88(%rbp)
jne 0x332e
jmp 0x334d
leaq 0x17dc4(%rip), %rdi     # 0x1b0f9
leaq 0x17d14(%rip), %rsi     # 0x1b050
movl $0x1f, %edx
leaq 0x17d12(%rip), %rcx     # 0x1b05a
callq 0x3040
cmpq $0x0, -0x58(%rbp)
jne 0x3356
jmp 0x3375
leaq 0x17db8(%rip), %rdi     # 0x1b115
leaq 0x17cec(%rip), %rsi     # 0x1b050
movl $0x20, %edx
leaq 0x17cea(%rip), %rcx     # 0x1b05a
callq 0x3040
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/evm.c
// Function: main
int main() {
    test_stop();
    test_mstoreReturn();
    test_math();
    test_shl();
    test_xorSwap();
    test_sgtslt();
    test_sdiv();
    test_smod();
    test_addmod();
    test_mulmod();
    test_exp();
    test_signextend();
    test_spaghetti();
    test_sstore_sload();
    test_sstore_refund();
    test_sstore_gauntlet();
    test_selfbalance();
    test_callEmpty();
    test_callBounce();
    test_coinbase();
    test_extcodecopy();
    test_deepCall();
    test_revertStorage();
    test_revertSload();
    test_log();
    test_sha3();
    test_delegateCall();

    // These last tests will write to stderr; usually we want this to be hushed
    close(2);

    test_staticcallSstore();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x31e0
callq 0x33e0
callq 0x35e0
callq 0x3930
callq 0x3ac0
callq 0x3d10
callq 0x3f30
callq 0x4200
callq 0x44d0
callq 0x4620
callq 0x4770
callq 0x4a20
callq 0x4c10
callq 0x4e40
callq 0x5080
callq 0x5230
callq 0x53f0
callq 0x5720
callq 0x5910
callq 0x5c40
callq 0x5fa0
callq 0x6c50
callq 0x7130
callq 0x7810
callq 0x8720
callq 0x95c0
callq 0xa9f0
movl $0x2, %edi
callq 0x3070
callq 0x7c30
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/examples/maths.c
// Function: main
int main(int argc, char **argv) {
  
  mpc_parser_t *Expr  = mpc_new("expression");
  mpc_parser_t *Prod  = mpc_new("product");
  mpc_parser_t *Value = mpc_new("value");
  mpc_parser_t *Maths = mpc_new("maths");
  
  mpca_lang(MPCA_LANG_PREDICTIVE,
    " expression : <product> (('+' | '-') <product>)*; "
    " product : <value>   (('*' | '/')   <value>)*;    "
    " value : /[0-9]+/ | '(' <expression> ')';         "
    " maths : /^/ <expression> /$/;                    ",
    Expr, Prod, Value, Maths, NULL);
  
  mpc_print(Expr);
  mpc_print(Prod);
  mpc_print(Value);
  mpc_print(Maths);
  
  if (argc > 1) {
    
    mpc_result_t r;
    if (mpc_parse_contents(argv[1], Maths, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
    
  } else {

    mpc_result_t r;
    if (mpc_parse_pipe("<stdin>", stdin, Maths, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
  
  }

  mpc_cleanup(4, Expr, Prod, Value, Maths);
  
  return 0;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xdd17(%rip), %rdi      # 0xf004
callq 0x38b0
movq %rax, -0x18(%rbp)
leaq 0xdd12(%rip), %rdi      # 0xf00f
callq 0x38b0
movq %rax, -0x20(%rbp)
leaq 0xdd0a(%rip), %rdi      # 0xf017
callq 0x38b0
movq %rax, -0x28(%rbp)
leaq 0xdd00(%rip), %rdi      # 0xf01d
callq 0x38b0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x1, %edi
leaq 0xdce1(%rip), %rsi      # 0xf023
xorl %eax, %eax
movq $0x0, (%rsp)
movb $0x0, %al
callq 0xa4d0
movq -0x18(%rbp), %rdi
callq 0x75f0
movq -0x20(%rbp), %rdi
callq 0x75f0
movq -0x28(%rbp), %rdi
callq 0x75f0
movq -0x30(%rbp), %rdi
callq 0x75f0
cmpl $0x1, -0x8(%rbp)
jle 0x13bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3550
cmpl $0x0, %eax
je 0x13ab
movq -0x38(%rbp), %rdi
callq 0x8550
movq -0x38(%rbp), %rdi
callq 0x7dd0
jmp 0x13bd
movq -0x38(%rbp), %rdi
callq 0x14b0
movq -0x38(%rbp), %rdi
callq 0x1430
jmp 0x140a
movq 0x12c1a(%rip), %rax     # 0x13fe0
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
leaq 0xdd18(%rip), %rdi      # 0xf0ec
leaq -0x40(%rbp), %rcx
callq 0x33b0
cmpl $0x0, %eax
je 0x13f6
movq -0x40(%rbp), %rdi
callq 0x8550
movq -0x40(%rbp), %rdi
callq 0x7dd0
jmp 0x1408
movq -0x40(%rbp), %rdi
callq 0x14b0
movq -0x40(%rbp), %rdi
callq 0x1430
jmp 0x140a
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x4, %edi
movb $0x0, %al
callq 0x3fb0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/demo2.c
// Function: main
int main(int argc, char** argv)
{
    void* a = evinisz(128);
    evpsh(a, "Test");
    evpsh(a, "Best");
    evpsh(a, "Rest");

    for(int i =0; i < evcnt(a); i++){
        char* s = (char*)evidx(a,i);
        printf("%i: %s\n", i, s);
    }

    a = evfree(a);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x80, %edi
movl $0x8, %esi
callq 0x12b0
movq %rax, -0x18(%rbp)
movl 0x13ff(%rip), %eax      # 0x339e
movl %eax, -0x1d(%rbp)
movb 0x13fa(%rip), %al       # 0x33a2
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x5, %edx
callq 0x1910
movq %rax, -0x18(%rbp)
jmp 0x1fc3
movl 0x13da(%rip), %eax      # 0x33a3
movl %eax, -0x22(%rbp)
movb 0x13d5(%rip), %al       # 0x33a7
movb %al, -0x1e(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x22(%rbp), %rsi
movl $0x5, %edx
callq 0x1910
movq %rax, -0x18(%rbp)
jmp 0x1fed
movl 0x13b5(%rip), %eax      # 0x33a8
movl %eax, -0x27(%rbp)
movb 0x13b0(%rip), %al       # 0x33ac
movb %al, -0x23(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x27(%rbp), %rsi
movl $0x5, %edx
callq 0x1910
movq %rax, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a70
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x206a
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1b00
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
leaq 0x1355(%rip), %rdi      # 0x33ad
movb $0x0, %al
callq 0x1050
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x201c
movq -0x18(%rbp), %rdi
callq 0x1ee0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhoudian64[P]OS2-exp/locker.c
// Function: main
int main() {
	int fd = open ("./lock", O_RDONLY | O_CREAT, 0666);
	while (1) {
		getchar();
	// 非共享🔒
		flock(fd, LOCK_EX);
		printf("Lock!\n");
		getchar();
		flock(fd, LOCK_UN);
		printf("UnLock!\n");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe7e(%rip), %rdi       # 0x2004
movl $0x40, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x1050
movl %eax, -0x8(%rbp)
callq 0x1040
movl -0x8(%rbp), %edi
movl $0x2, %esi
callq 0x1060
leaq 0xe5a(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x1030
callq 0x1040
movl -0x8(%rbp), %edi
movl $0x8, %esi
callq 0x1060
leaq 0xe38(%rip), %rdi       # 0x200b
movb $0x0, %al
callq 0x1030
jmp 0x119a
// File: /workspace/github_c_makefile_star2_O0/kisom[P]kam/queue.c
// Function: new_queue8
queue8
new_queue8()
{
	queue8	q;

	q = malloc(sizeof(struct s_queue8));
	if (NULL == q)
		abort();
	q->head = NULL;
	q->tail = NULL;
	q->nodes = 0;
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1080
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x11c3
callq 0x1040
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq