LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_str2int.c
// Function: check_strprint2
static int
check_strprint2(int verbose, const char *str, size_t len, size_t destlen,
                char quote, const char *expect) {
    char buf[100];
    hts_strprint(buf, destlen, quote, str, len);
    if (strcmp(buf, expect) != 0) {
        fprintf(stderr, "hts_strprint failed: length %zu: got \"%.*s\", "
                "expected \"%s\"\n", destlen, (int) destlen, buf, expect);
        return -1;
    }
    else if (verbose) {
        fprintf(stderr, "hts_strprint OK: length %zu: got \"%s\"\n",
                destlen, expect);
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %rax
movq %rsi, %rcx
movl %edi, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %r8d, %edx
movq %rax, %r8
callq 0x6f7a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x46c0
testl %eax, %eax
jne 0x65d5
xorl %r15d, %r15d
testl %ebp, %ebp
jne 0x65ff
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x92a04(%rip), %rax     # 0x98fe0
movq (%rax), %rdi
leaq 0x6bc28(%rip), %rsi     # 0x7220e
movq %rsp, %r8
movq %r14, %rdx
movl %r14d, %ecx
movq %rbx, %r9
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %r15
jmp 0x65c7
movq 0x929da(%rip), %rax     # 0x98fe0
movq (%rax), %rdi
leaq 0x6bc3a(%rip), %rsi     # 0x7224a
xorl %r15d, %r15d
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4700
jmp 0x65c7
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x2571
testq %r15, %r15
setne %al
testq %rbx, %rbx
sete %cl
testb %cl, %al
jne 0x2571
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x2568
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2190
testl %eax, %eax
jne 0x2571
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2acb(%rip), %rdi      # 0x5043
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x246d
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x25ea
testq %r15, %r15
setne %al
testq %rbx, %rbx
sete %cl
testb %cl, %al
jne 0x25ea
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x25e1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2040
testl %eax, %eax
jne 0x25ea
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a71(%rip), %rdi      # 0x5062
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x246d
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r10
cmpq %rcx, %rsi
jne 0x2646
xorl %eax, %eax
cmpq %rax, %r10
je 0x262a
movzbl (%rdi,%rax), %ecx
movzbl (%rdx,%rax), %r11d
cmpb %r11b, %cl
jne 0x262c
incq %rax
jmp 0x2612
popq %rbp
retq
leaq 0x2a73(%rip), %rdi      # 0x50a6
movq %r8, %rsi
movl %r9d, %edx
movq %rax, %r8
movl %r11d, %r9d
xorl %eax, %eax
callq 0x246d
movq %rcx, %rax
leaq 0x2a33(%rip), %rdi      # 0x5083
movq %r8, %rsi
movl %r9d, %edx
movq %r10, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x246d
// File: /workspace/github_c_makefile_star2_O2/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:
movapd %xmm2, %xmm3
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x28d5(%rip), %xmm4     # 0x5010
xorpd %xmm2, %xmm4
maxsd %xmm2, %xmm4
ucomisd %xmm3, %xmm4
ja 0x274a
retq
pushq %rbp
movq %rsp, %rbp
movl %esi, %edx
movq %rdi, %rsi
leaq 0x2a08(%rip), %rdi      # 0x5162
movb $0x4, %al
callq 0x246d
// File: /workspace/github_c_makefile_star2_O2/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:
movapd %xmm2, %xmm3
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x289b(%rip), %xmm4     # 0x5010
xorpd %xmm2, %xmm4
maxsd %xmm2, %xmm4
ucomisd %xmm4, %xmm3
jae 0x2784
retq
pushq %rbp
movq %rsp, %rbp
movl %esi, %edx
movq %rdi, %rsi
leaq 0x29ce(%rip), %rdi      # 0x5162
movb $0x4, %al
callq 0x246d
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2130
imulq $0xf4240, (%rbx), %rax  # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rdx
cmpl $0x0, 0x55de(%rip)      # 0x8128
je 0x2b5e
movq %rdi, %rsi
leaq 0x2740(%rip), %rdi      # 0x5296
xorl %eax, %eax
popq %rbp
jmp 0x2100
movq %rdx, %rdi
popq %rbp
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r15
movabsq $0x300000000, %rax      # imm = 0x300000000
imulq %r15, %rax
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
pushq $0x1
popq %rsi
callq 0x2180
movq %rax, %r14
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
xorl %edx, %edx
movslq %edx, %rsi
cmpq %rax, %rcx
je 0x3c36
movzbl (%rbx,%rax), %edi
cmpl $0x3e, %edi
je 0x3c16
cmpl $0x3c, %edi
jne 0x3c2b
movw $0x6c26, (%r14,%rsi)    # imm = 0x6C26
jmp 0x3c1d
movw $0x6726, (%r14,%rsi)    # imm = 0x6726
movb $0x74, 0x2(%r14,%rsi)
addq $0x2, %rsi
movl %esi, %edx
jmp 0x3c2f
movb %dil, (%r14,%rsi)
incq %rax
incl %edx
jmp 0x3bf7
movb $0x0, (%r14,%rsi)
movq %rbx, %rdi
callq 0x2030
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
pushq $0x8
popq %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2070
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x2120
testq %rax, %rax
je 0x3cb1
subl %ebx, %eax
cltq
movb $0x0, (%r14,%rax)
pushq $0x2f
popq %rsi
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rcx
testq %rax, %rax
leaq 0x1e83(%rip), %rax      # 0x5b2e
cmovneq %rcx, %rax
jmp 0x3cb8
leaq 0x1e76(%rip), %rax      # 0x5b2e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
callq 0x20c0
testq %rax, %rax
je 0x3d9b
movq %rax, %r13
movq %r13, %rdi
callq 0x21c0
testq %rax, %rax
je 0x3d91
cmpb $0x2e, 0x13(%rax)
je 0x3cec
cmpl $0x1e, (%rbx)
je 0x3dab
movq %rax, %r12
addq $0x13, %r12
cmpb $0x4, 0x12(%rax)
jne 0x3d48
leaq -0x230(%rbp), %r14
movq %r14, %rdi
leaq 0x1d3a(%rip), %rsi      # 0x5a64
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0x3cbd
jmp 0x3cec
movl $0xff, %edi
pushq $0x1
popq %rsi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
leaq 0x1d02(%rip), %rsi      # 0x5a64
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movslq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq (%rcx,%rax,8), %rdi
movq %r14, %rsi
callq 0x2070
movq %r14, %rdi
callq 0x2030
incl (%rbx)
jmp 0x3cec
movq %r13, %rdi
callq 0x2150
jmp 0x3da7
leaq 0x1e07(%rip), %rdi      # 0x5ba9
callq 0x2080
xorl %eax, %eax
jmp 0x3dae
pushq $-0x1
popq %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x1d88(%rip), %rsi      # 0x5b60
callq 0x21f0
testq %rax, %rax
je 0x3e83
movq %rax, %r14
pushq $0x8
popq %rsi
movl $0xc350, %edi           # imm = 0xC350
callq 0x2180
movq %rax, %rbx
xorl %r12d, %r12d
pushq $0x1
popq %r15
cmpq $0xc350, %r12           # imm = 0xC350
je 0x3e1f
movl $0x1f4, %edi            # imm = 0x1F4
movq %r15, %rsi
callq 0x2180
movq %rax, (%rbx,%r12,8)
incq %r12
jmp 0x3e00
xorl %r13d, %r13d
pushq $0x1
popq %r15
cmpq $0xc350, %r13           # imm = 0xC350
je 0x3e79
movl $0x1f4, %edi            # imm = 0x1F4
movq %r15, %rsi
callq 0x2180
movq %rax, %r12
movq %rax, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %r14, %rdx
callq 0x2160
testq %rax, %rax
jne 0x3e60
movq %r14, %rdi
callq 0x21a0
testl %eax, %eax
jne 0x3e79
movq (%rbx,%r13,8), %rdi
movq %r12, %rsi
callq 0x2070
incq %r13
movq %r12, %rdi
callq 0x2030
jmp 0x3e26
movq %r14, %rdi
callq 0x20b0
jmp 0x3ea4
leaq 0x1be2(%rip), %rdi      # 0x5a6c
leaq 0x1be3(%rip), %rsi      # 0x5a74
leaq 0x1be5(%rip), %rcx      # 0x5a7d
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x2100
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x1bab(%rip), %rdi      # 0x5a8e
leaq 0x1bab(%rip), %rsi      # 0x5a95
leaq 0x1bcc(%rip), %rdx      # 0x5abd
xorl %eax, %eax
callq 0x2100
leaq 0x1be3(%rip), %rdi      # 0x5ae2
callq 0x2080
leaq 0x1bea(%rip), %rbx      # 0x5af5
leaq 0x13db(%rip), %rsi      # 0x52ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x13d8(%rip), %rsi      # 0x52fb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x13f8(%rip), %rsi      # 0x532c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x13dd(%rip), %rsi      # 0x5322
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jne 0x3f81
leaq 0x1b26(%rip), %rdi      # 0x5a8e
leaq 0x1b26(%rip), %rsi      # 0x5a95
leaq 0x1b47(%rip), %rdx      # 0x5abd
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2100
jmp 0x3fea
cmpl $0x6, %edi
setl %al
cmpl $0x4, %edi
setne %cl
testb %cl, %al
jne 0x3fa3
leaq 0x1b62(%rip), %rdi      # 0x5afa
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2100
jmp 0x3fea
pushq $0x1
popq %rbx
cmpl $0x2, %edi
jne 0x3fea
movq 0x8(%rsi), %r14
leaq 0x1376(%rip), %rsi      # 0x532c
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x3fe3
leaq 0x1359(%rip), %rsi      # 0x5322
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
jne 0x3fea
leaq 0x1b41(%rip), %rdi      # 0x5b1d
callq 0x2080
jmp 0x3fe8
callq 0x3ed6
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
pushq $0x1
popq %rcx
leal -0x1(%rcx), %edx
cmpq %rdx, %rax
jbe 0x418b
cmpb $0x2f, (%rbx,%rdx)
jne 0x4187
movl %ecx, %esi
cmpb $0x2f, (%rbx,%rsi)
je 0x418b
incl %ecx
jmp 0x4171
xorl %ecx, %ecx
cmpq %rdx, %rax
seta %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rax
leaq 0x1(%rdi), %rcx
movzbl -0x1(%rcx), %edx
cmpl $0x2f, %edx
je 0x424e
testl %edx, %edx
jne 0x4259
jmp 0x425e
cmpb $0x2a, (%rcx)
jne 0x4259
movw $0x2020, -0x1(%rcx)     # imm = 0x2020
incq %rcx
jmp 0x423f
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rax
leaq 0x1(%rdi), %rcx
movzbl -0x1(%rcx), %edx
cmpl $0x2a, %edx
je 0x427a
testl %edx, %edx
jne 0x4285
jmp 0x428a
cmpb $0x2f, (%rcx)
jne 0x4285
movw $0x2020, -0x1(%rcx)     # imm = 0x2020
incq %rcx
jmp 0x426b
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
xorl %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x42b9
movzbl (%rbx,%rcx), %edx
cmpl $0x20, %edx
jne 0x42b0
incl %ecx
jmp 0x429c
cmpl $0x2a, %edx
jne 0x42b9
movb $0x20, (%rbx,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x3eb6
movq %rax, %rbx
leaq 0x18ea(%rip), %r14      # 0x5bc8
xorl %ecx, %ecx
movq %r14, %r15
movq %rcx, %r12
cmpq $0x3, %rcx
je 0x4307
movslq (%r15), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x2190
leaq 0x1(%r12), %rcx
addq $0x4, %r15
testl %eax, %eax
jne 0x42e3
xorl %eax, %eax
cmpq $0x3, %r12
setb %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
callq 0x21b0
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2050
movq %rax, %rdi
callq 0x20e0
movq %rax, %r14
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x43d5
testl %ecx, %ecx
jne 0x43d8
jmp 0x43dd
movb $0x5f, (%rax)
incq %rax
jmp 0x43c7
movq %r14, %rdi
callq 0x20d0
cmpb $0xa, -0x1(%r14,%rax)
jne 0x43f3
movb $0x0, -0x1(%r14,%rax)
movq %r15, %rdi
callq 0x20d0
leaq 0x32(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x2180
movq %rax, %r12
movq %r15, %rdi
callq 0x3c51
leaq 0x18ad(%rip), %r10      # 0x5cc6
leaq 0x17b4(%rip), %rsi      # 0x5bd4
leaq 0x1177(%rip), %rcx      # 0x559e
leaq 0x17b3(%rip), %r9       # 0x5be1
movq %r12, %rdi
movq %rbx, %rdx
movq %rax, %r8
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x2200
popq %rcx
popq %rdx
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x3eb6
movzbl (%rax), %ecx
cmpl $0x63, %ecx
je 0x4479
cmpl $0x68, %ecx
jne 0x447f
cmpb $0x0, 0x1(%rax)
jne 0x447f
leaq 0x176c(%rip), %rax      # 0x5be3
jmp 0x44a2
cmpb $0x0, 0x1(%rax)
je 0x44a4
leaq 0xeb8(%rip), %rsi       # 0x533e
movq %rax, %rdi
callq 0x2190
testl %eax, %eax
leaq 0x17ae(%rip), %rcx      # 0x5c45
leaq 0x1690(%rip), %rax      # 0x5b2e
cmoveq %rcx, %rax
popq %rbp
retq
leaq 0x176e(%rip), %rax      # 0x5c19
jmp 0x44a2
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4160
movl %eax, %r14d
movq %rbx, %rdi
callq 0x419c
movl %eax, %r15d
movq %rbx, %rdi
callq 0x41d8
orl %r14d, %r15d
xorl %ecx, %ecx
orl %eax, %r15d
sete %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x18
popq %rdi
callq 0x12e0
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
addq $0x8, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x134b
movq %rdi, %rbx
decl -0x8(%rdi)
je 0x1353
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq -0x8(%rbx), %r14
movq (%rbx), %rdi
callq 0x133a
movq 0x8(%rbx), %rdi
callq 0x133a
pushq $0x18
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x130a
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x90, %rsp
xorl %eax, %eax
callq 0xaa8d
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0x332c
leaq 0x27(%rsp), %r8
movb $0x0, (%r8)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
leaq 0x28(%rsp), %rbx
leaq 0x6c(%rsp), %rdx
pushq $0x1
popq %rcx
movl $0xcf0e, %esi           # imm = 0xCF0E
movq %rbx, %rdi
callq 0xb68f
xorl %eax, %eax
callq 0xada8
cmpq $0x0, 0x10(%rbx)
jne 0x3292
movl $0x80d9b122, %eax       # imm = 0x80D9B122
cmpq %rax, 0x40(%rsp)
jne 0x32ab
movabsq $-0x23c5e9023be06931, %rax # imm = 0xDC3A16FDC41F96CF
cmpq %rax, 0x48(%rsp)
jne 0x32c4
movabsq $0x10ffe7e38d227c3, %rax # imm = 0x10FFE7E38D227C3
cmpq %rax, 0x50(%rsp)
jne 0x32dd
cmpq $0x0, 0x28(%rsp)
jne 0x32f6
cmpq $0x0, 0x58(%rsp)
jne 0x330f
addq $0x90, %rsp
popq %rbx
retq
leaq 0xdd96(%rip), %rdi      # 0x1102f
leaq 0xddb0(%rip), %rsi      # 0x11050
leaq 0xddb3(%rip), %rcx      # 0x1105a
pushq $0x1b
jmp 0x3326
leaq 0xddb9(%rip), %rdi      # 0x1106b
leaq 0xdd97(%rip), %rsi      # 0x11050
leaq 0xdd9a(%rip), %rcx      # 0x1105a
pushq $0x1c
jmp 0x3326
leaq 0xddca(%rip), %rdi      # 0x11095
leaq 0xdd7e(%rip), %rsi      # 0x11050
leaq 0xdd81(%rip), %rcx      # 0x1105a
pushq $0x1d
jmp 0x3326
leaq 0xdde3(%rip), %rdi      # 0x110c7
leaq 0xdd65(%rip), %rsi      # 0x11050
leaq 0xdd68(%rip), %rcx      # 0x1105a
pushq $0x1e
jmp 0x3326
leaq 0xddfc(%rip), %rdi      # 0x110f9
leaq 0xdd4c(%rip), %rsi      # 0x11050
leaq 0xdd4f(%rip), %rcx      # 0x1105a
pushq $0x1f
jmp 0x3326
leaq 0xddff(%rip), %rdi      # 0x11115
leaq 0xdd33(%rip), %rsi      # 0x11050
leaq 0xdd36(%rip), %rcx      # 0x1105a
pushq $0x20
popq %rdx
callq 0x3040
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/tst/evm.c
// Function: test_sstore_refund
void test_sstore_refund() {
    evmInit();

    // 5f5f5560015f555f5f5500
    op_t program[] = {
        PUSH0, PUSH0, SSTORE,
        PUSH1, 0x01, PUSH0, SSTORE,
        PUSH0, PUSH0, SSTORE,
        STOP,
    };
    address_t from = AddressFromHex42("0x4a6f6B9fF1fc974096f9063a45Fd12bD5B928AD1");
    uint64_t gas = 77680;
    val_t value;
    data_t input;
    input.content = program;
    input.size = sizeof(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 == 17296);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
xorl %eax, %eax
callq 0xaa8d
movabsq $0x5f555f0160555f5f, %rax # imm = 0x5F555F0160555F5F
leaq 0x58(%rsp), %rbx
movq %rax, (%rbx)
movl $0x555f5f, 0x7(%rbx)    # imm = 0x555F5F
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x332c
movl 0x10(%r14), %eax
movl %eax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x18(%rsp), %r14
leaq 0x64(%rsp), %rdx
pushq $0xb
popq %rcx
movl $0x12f70, %esi          # imm = 0x12F70
movq %r14, %rdi
movq %rbx, %r8
callq 0xb68f
xorl %eax, %eax
callq 0xada8
cmpq $0x0, 0x10(%r14)
jne 0x4a9e
movl $0x80d9b122, %eax       # imm = 0x80D9B122
cmpq %rax, 0x30(%rsp)
jne 0x4abd
movabsq $-0x23c5e9023be06931, %rax # imm = 0xDC3A16FDC41F96CF
cmpq %rax, 0x38(%rsp)
jne 0x4adc
movabsq $0x10ffe7e38d227c3, %rax # imm = 0x10FFE7E38D227C3
cmpq %rax, 0x40(%rsp)
jne 0x4afb
cmpq $0x0, 0x18(%rsp)
jne 0x4b1a
cmpq $0x4390, 0x48(%rsp)     # imm = 0x4390
jne 0x4b39
addq $0x88, %rsp
popq %rbx
popq %r14
retq
leaq 0xc58a(%rip), %rdi      # 0x1102f
leaq 0xc5a4(%rip), %rsi      # 0x11050
leaq 0xcbc4(%rip), %rcx      # 0x11677
movl $0x337, %edx            # imm = 0x337
callq 0x3040
leaq 0xc5a7(%rip), %rdi      # 0x1106b
leaq 0xc585(%rip), %rsi      # 0x11050
leaq 0xcba5(%rip), %rcx      # 0x11677
movl $0x338, %edx            # imm = 0x338
callq 0x3040
leaq 0xc5b2(%rip), %rdi      # 0x11095
leaq 0xc566(%rip), %rsi      # 0x11050
leaq 0xcb86(%rip), %rcx      # 0x11677
movl $0x339, %edx            # imm = 0x339
callq 0x3040
leaq 0xc5c5(%rip), %rdi      # 0x110c7
leaq 0xc547(%rip), %rsi      # 0x11050
leaq 0xcb67(%rip), %rcx      # 0x11677
movl $0x33a, %edx            # imm = 0x33A
callq 0x3040
leaq 0xc5d8(%rip), %rdi      # 0x110f9
leaq 0xc528(%rip), %rsi      # 0x11050
leaq 0xcb48(%rip), %rcx      # 0x11677
movl $0x33b, %edx            # imm = 0x33B
callq 0x3040
leaq 0xcb51(%rip), %rdi      # 0x11691
leaq 0xc509(%rip), %rsi      # 0x11050
leaq 0xcb29(%rip), %rcx      # 0x11677
movl $0x33c, %edx            # imm = 0x33C
callq 0x3040
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x31ec
callq 0x3385
callq 0x352f
callq 0x3769
callq 0x38b3
callq 0x3ab5
callq 0x3c80
callq 0x3e5d
callq 0x403a
callq 0x413c
callq 0x423e
callq 0x447c
callq 0x4600
callq 0x47da
callq 0x49d4
callq 0x4b58
callq 0x4ce4
callq 0x4f62
callq 0x510b
callq 0x5398
callq 0x56d2
callq 0x5fdd
callq 0x63de
callq 0x6917
callq 0x76ba
callq 0x8317
callq 0x9371
pushq $0x2
popq %rdi
callq 0x3070
callq 0x6ca9
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movl %edi, %ebp
leaq 0x7cce(%rip), %rdi      # 0x9004
callq 0x2be6
movq %rax, %rbx
leaq 0x7cca(%rip), %rdi      # 0x900f
callq 0x2be6
movq %rax, %r14
leaq 0x7cc3(%rip), %rdi      # 0x9017
callq 0x2be6
movq %rax, %r15
leaq 0x7cba(%rip), %rdi      # 0x901d
callq 0x2be6
movq %rax, %r12
andq $0x0, (%rsp)
leaq 0x7cac(%rip), %rsi      # 0x9023
pushq $0x1
popq %rdi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x716a
movq %rbx, %rdi
callq 0x530f
movq %r14, %rdi
callq 0x530f
movq %r15, %rdi
callq 0x530f
movq %r12, %rdi
callq 0x530f
cmpl $0x2, %ebp
jl 0x13c8
movq 0x8(%r13), %rdi
leaq 0x10(%rsp), %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x29df
jmp 0x13e9
movq 0xcc11(%rip), %rax      # 0xdfe0
movq (%rax), %rsi
leaq 0x7d13(%rip), %rdi      # 0x90ec
leaq 0x10(%rsp), %r13
movq %r12, %rdx
movq %r13, %rcx
callq 0x2919
movq (%r13), %rdi
testl %eax, %eax
je 0x1402
callq 0x5cbd
movq 0x10(%rsp), %rdi
callq 0x58bb
jmp 0x1411
callq 0x1483
movq 0x10(%rsp), %rdi
callq 0x1438
pushq $0x4
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2fda
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq $0x8
popq %rsi
movl $0x80, %edi
callq 0x1280
leaq 0xa27(%rip), %rsi       # 0x2380
pushq $0x5
popq %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x1630
leaq 0xa17(%rip), %rsi       # 0x2385
movq %rax, %rdi
movq %rbx, %rdx
callq 0x1630
leaq 0xa0a(%rip), %rsi       # 0x238a
movq %rax, %rdi
movq %rbx, %rdx
callq 0x1630
movq %rax, %rbx
leaq 0x9fa(%rip), %r14       # 0x238f
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x16fd
cmpq %r15, %rax
jbe 0x19c5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x173e
movq %r14, %rdi
movl %r15d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
incq %r15
jmp 0x1998
movq %rbx, %rdi
callq 0x18fa
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe83(%rip), %rdi       # 0x2004
pushq $0x40
popq %rsi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x1050
movl %eax, %ebx
pushq $0x2
popq %r14
leaq 0xe70(%rip), %r15       # 0x200d
pushq $0x8
popq %r12
leaq 0xe63(%rip), %r13       # 0x200b
callq 0x1040
movl %ebx, %edi
movl %r14d, %esi
callq 0x1060
movq %r15, %rdi
callq 0x1030
callq 0x1040
movl %ebx, %edi
movl %r12d, %esi
callq 0x1060
movq %r13, %rdi
callq 0x1030
jmp 0x11a8
// File: /workspace/github_c_makefile_star2_O2/kisom[P]kam/queue.c
// Function: dequeue8
uint8_t
dequeue8(queue8 q)
{
	struct node8	*node;
	uint8_t	val;

	if (NULL == q->head)
		abort();

	node = q->head;
	val = node->val;

	q->head = node->next;
	free(node);
	q->nodes--;
	if (0 == q->nodes)
		q->tail = NULL;
	return val;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1259
movb (%rdi), %bpl
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
callq 0x1030
decq 0x10(%rbx)
jne 0x1250
andq $0x0, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/kisom[P]kam/qtest.c
// Function: main
static void
test_queue8(void)
{
	uint8_t val;
	queue8	st;

	st = new_queue8();
	if (st == NULL) {
		errx(EX_OSERR, "FAILED: malloc failure");
	}

	enqueue8(st, 1);
	enqueue8(st, 2);
	if (1 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 2 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}

	enqueue8(st, 3);
	if (2 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 3 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}
	if (3 != (val = dequeue8(st)))
		errx(EX_SOFTWARE,
		    "FAILED: should have received 1 from the queue.");
	if (!empty_queue8(st))
		errx(EX_SOFTWARE,
		    "FAILED: queue should report empty.");
	enqueue8(st, 5);
	enqueue8(st, 5);
	destroy_queue8(st);
	printf("queue8: OK\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x11bc
testq %rax, %rax
je 0x1450
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x11d4
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11d4
movq %rbx, %rdi
callq 0x1228
cmpb $0x1, %al
jne 0x145b
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11d4
movq %rbx, %rdi
callq 0x1228
cmpb $0x2, %al
jne 0x1471
movq %rbx, %rdi
callq 0x1228
cmpb $0x3, %al
jne 0x14ab
movq %rbx, %rdi
callq 0x125e
testl %eax, %eax
je 0x14b4
pushq $0x5
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11d4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11d4
movq %rbx, %rdi
callq 0x1269
leaq 0xca0(%rip), %rdi       # 0x20e4
callq 0x1050
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbad(%rip), %rsi       # 0x2004
pushq $0x47
jmp 0x14bd
movzbl %al, %ebx
movq 0x2b93(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0xbac(%rip), %rdi       # 0x201b
jmp 0x1485
movzbl %al, %ebx
movq 0x2b7d(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0xbdd(%rip), %rdi       # 0x2062
pushq $0x2f
popq %rsi
pushq $0x1
popq %rdx
callq 0x10b0
movq (%r14), %rdi
leaq 0xbb1(%rip), %rsi       # 0x204b
movl %ebx, %edx
xorl %eax, %eax
callq 0x1080
pushq $0x1
popq %rdi
callq 0x10a0
leaq 0xbe0(%rip), %rsi       # 0x2092
jmp 0x14bb
leaq 0xc06(%rip), %rsi       # 0x20c1
pushq $0x46
popq %rdi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/minkcv[P]vm/assembler.c
// Function: countInstructions
int countInstructions(FILE* src)
{
    char* line = NULL;
    size_t toRead = 0; // Read until \n
    ssize_t charsRead;
    uint16_t instrCount = 0;
    while ((charsRead = getline(&line, &toRead, src)) != -1)
    {
        if (line[0] != '\n' && line[0] != '@' && line[0] != ';')
        {
            char* token = strtok(line, " ");
            if (!strcmp(token, "LRL"))
                instrCount++;
            instrCount++;
        }
        free(line);
        line = NULL; // Causes getline to keep reading
    }
    rewind(src);
    return instrCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
andq $0x0, (%r14)
leaq -0x38(%rbp), %r15
andq $0x0, (%r15)
xorl %r12d, %r12d
movabsq $0x42000000000001, %r13 # imm = 0x42000000000001
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1150
cmpq $-0x1, %rax
je 0x1b8a
movq -0x30(%rbp), %rdi
movzbl (%rdi), %eax
addl $-0xa, %eax
cmpl $0x36, %eax
ja 0x1b54
btq %rax, %r13
jb 0x1b7e
leaq 0x502(%rip), %rsi       # 0x205d
callq 0x1130
movq %rax, %rdi
leaq 0x4ef(%rip), %rsi       # 0x2059
callq 0x10c0
cmpl $0x1, %eax
adcw $0x0, %r12w
incl %r12d
movq -0x30(%rbp), %rdi
callq 0x1030
andq $0x0, -0x30(%rbp)
jmp 0x1b2b
movq %rbx, %rdi
callq 0x10b0
movzwl %r12w, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/minkcv[P]vm/assembler.c
// Function: createLabelMap
void createLabelMap(FILE* src, LabelAddress*** labelMap)
{
    char* line = NULL;
    size_t toRead = 0; // Read until \n
    ssize_t charsRead;
    int labelCount = 0;
    uint16_t instrCount = 0;
    while ((charsRead = getline(&line, &toRead, src)) != -1)
    {
        if(line[0] == '@')
        {
            // Create the label entry in labelMap
            char* start = line;
            char* beforeAt = strsep(&line, "@");
            char* labelName = strsep(&line, " ;\n"); // Trim any comments or other text off the end
            LabelAddress* labeladdr = malloc(sizeof(LabelAddress));
            labeladdr->label = malloc(sizeof(char) * (strlen(labelName) + 1));
            strcpy(labeladdr->label, labelName);
            labeladdr->segAddr = instrCount / JUMP_SEGMENT_SIZE;
            labeladdr->offsetAddr = instrCount % JUMP_SEGMENT_SIZE;
            (*labelMap)[labelCount] = labeladdr;
            labelCount++;
            free(start);
            start = NULL;
            labelName = NULL;
            beforeAt = NULL;
            line = NULL;
        }
        else if (line[0] != ';' && line[0] != '\n')
        {
            char* token = strtok(line, " ");
            if (!strcmp(token, "LRL"))
                instrCount++;
            instrCount++;
            free(line);
            line = NULL;
        }
        else
        {
            free(line);
            line = NULL;
        }
    }
    rewind(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x50(%rbp)
leaq -0x30(%rbp), %r14
andq $0x0, (%r14)
leaq -0x58(%rbp), %r12
andq $0x0, (%r12)
movq %rdi, %r15
xorl %ebx, %ebx
movq $0x0, -0x48(%rbp)
movl %ebx, %eax
shrl $0x8, %eax
movl %eax, -0x38(%rbp)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1150
cmpq $-0x1, %rax
je 0x1cd6
movq -0x30(%rbp), %r13
movzbl (%r13), %eax
cmpl $0xa, %eax
je 0x1c0b
cmpl $0x3b, %eax
jne 0x1c1a
movq %r13, %rdi
callq 0x1030
andq $0x0, -0x30(%rbp)
jmp 0x1be0
cmpl $0x40, %eax
jne 0x1c9c
movq %r14, %rdi
leaq 0x436(%rip), %rsi       # 0x205f
callq 0x1100
movq %r14, %rdi
leaq 0x41d(%rip), %rsi       # 0x2055
callq 0x1100
movq %rax, -0x40(%rbp)
pushq $0x10
popq %rdi
callq 0x10f0
movl %ebx, -0x34(%rbp)
movq %rax, %rbx
movq -0x40(%rbp), %rdi
callq 0x1090
leaq 0x1(%rax), %rdi
callq 0x10f0
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x1050
movl -0x38(%rbp), %eax
movb %al, (%rbx)
movl -0x34(%rbp), %eax
movb %al, 0x1(%rbx)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq -0x48(%rbp), %rcx
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
movl -0x34(%rbp), %ebx
incl %ecx
movq %rcx, -0x48(%rbp)
jmp 0x1c0b
movq %r13, %rdi
leaq 0x3b7(%rip), %rsi       # 0x205d
callq 0x1130
movq %rax, %rdi
leaq 0x3a4(%rip), %rsi       # 0x2059
callq 0x10c0
cmpl $0x1, %eax
adcw $0x0, %bx
incl %ebx
movq -0x30(%rbp), %rdi
callq 0x1030
andq $0x0, -0x30(%rbp)
jmp 0x1bd8
movq %r15, %rdi
callq 0x10b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/minkcv[P]vm/assembler.c
// Function: getAddressesOfLabel
void getAddressesOfLabel(char* label, LabelAddress* labelMap[MAX_LABELS], uint8_t* segAddr, uint8_t* offsetAddr)
{
    int i;
    for (i = 0; i < MAX_LABELS; i++)
    {
        LabelAddress* current = labelMap[i];
        if (current != NULL && current->label != NULL)
        {
            if (!strcmp(current->label, label))
            {
                *segAddr = current->segAddr;
                *offsetAddr = current->offsetAddr;
                return;
            }
        }
    }
    printf("Error: Label \"%s\" not defined\n", label);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %r13d, %r13d
cmpq $0x400, %r13            # imm = 0x400
je 0x1d54
movq (%r12,%r13,8), %rbx
testq %rbx, %rbx
je 0x1d32
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d32
movq %r14, %rsi
callq 0x10c0
testl %eax, %eax
je 0x1d37
incq %r13
jmp 0x1d0b
movb (%rbx), %al
movb %al, (%r15)
movb 0x1(%rbx), %al
movq -0x30(%rbp), %rcx
movb %al, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b5(%rip), %rdi       # 0x2110
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_08/atexit.c
// Function: main
int main(void)
{
	long atexit_max;
	int ret;

#ifdef ATEXIT_MAX
	atexit_max = ATEXIT_MAX;
#else
	errno = 0;
	atexit_max = sysconf(_SC_ATEXIT_MAX);
	if (atexit_max < 0) {
		if (errno == 0) {
			fprintf(stderr, "_SC_ATEXIT_MAX limit not supported\n");
		} else {
			perror("sysconf");
			return -1;
		}
	}
#endif
	printf("ATEXIT_MAX = %ld\n", atexit_max);

	ret = atexit(func1);
	if (ret) {
		fprintf(stderr, "cannot set atexit func1\n");
		return -1;
	}

	ret = atexit(func2);
	if (ret) {
		fprintf(stderr, "cannot set atexit func2\n");
		return -1;
	}

	printf("press ENTER to continue >");
	getchar();

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1030
movq %rax, %r14
andl $0x0, (%rax)
pushq $0x57
popq %rdi
callq 0x1080
movq %rax, %rbx
testq %rax, %rax
js 0x1233
leaq 0xe46(%rip), %rdi       # 0x2030
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
leaq -0x4f(%rip), %rdi       # 0x11ac
callq 0x12a0
testl %eax, %eax
jne 0x1257
leaq -0x53(%rip), %rdi       # 0x11b8
callq 0x12a0
testl %eax, %eax
jne 0x126a
leaq 0xe59(%rip), %rdi       # 0x2074
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1050
callq 0x1060
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, (%r14)
jne 0x1288
movq 0x2db8(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdba(%rip), %rdi       # 0x2004
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
jmp 0x11e3
movq 0x2d9a(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdda(%rip), %rdi       # 0x2042
jmp 0x127b
movq 0x2d87(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xde0(%rip), %rdi       # 0x205b
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
jmp 0x1294
leaq 0xd99(%rip), %rdi       # 0x2028
callq 0x1070
pushq $-0x1
popq %rbx
jmp 0x1229
nopl (%rax)