LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/fflz4.c
// Function: get_tabs
void get_tabs(const char *path, const unsigned int flag)
{
    cJSON *json = NULL;
    char *buf = NULL, *result = NULL;
    int len = 0;

    len = path[strlen(path)-1] == '/' ? asprintf(&buf, "%s%s/%s", path, SESSION, TABS) : asprintf(&buf, "%s/%s/%s", path, SESSION, TABS);
    if (!len) FAILED(0, "Not enough memory\n");

    result = extract_jsonlz4(buf);
    if (!result) FAILED(0, "Failed to read jsonlz4 at: %s\n", buf);

    json = cJSON_Parse(result);
    if (!json) goto cleanup;

    if (flag & FLAG_S) {
        char *js = cJSON_Print(json);
        fprintf(stdout, "%s\n", js);
        free(js);
        goto cleanup;
    }

    const cJSON *windows = cJSON_GetObjectItemCaseSensitive(json, "windows");
    if (!cJSON_IsArray(windows)) goto cleanup;

    print_tabs(windows, flag);

cleanup:
    if (json) cJSON_Delete(json);
    free(buf);
    free(result);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
callq 0x10a0
cmpb $0x2f, -0x1(%rbx,%rax)
leaq 0xdb14(%rip), %rax      # 0xf160
leaq 0xdb15(%rip), %rsi      # 0xf168
cmoveq %rax, %rsi
leaq 0xdba5(%rip), %rcx      # 0xf203
leaq 0xdbb3(%rip), %r8       # 0xf218
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1180
testl %eax, %eax
je 0x1718
movq (%rsp), %rdi
callq 0x1a1d
movq %rax, %rbx
movq %rax, %rdi
callq 0xd2f0
testq %rax, %rax
je 0x16fc
movq %rax, %r14
testb $0x20, %bpl
jne 0x16c6
leaq 0xdace(%rip), %rsi      # 0xf171
movq %r14, %rdi
callq 0xda12
movq %rax, %r15
movq %rax, %rdi
callq 0xe6f9
testl %eax, %eax
je 0x16f4
movq %r15, %rdi
movl %ebp, %esi
callq 0x1bc4
jmp 0x16f4
movq %r14, %rdi
callq 0xd2f9
movq %rax, %r15
movq 0x118e0(%rip), %rax     # 0x12fb8
movq (%rax), %rdi
leaq 0xdacc(%rip), %rsi      # 0xf1ae
movq %r15, %rdx
xorl %eax, %eax
callq 0x1100
movq %r15, %rdi
callq 0x1230
movq %r14, %rdi
callq 0xcc3e
movq (%rsp), %rdi
callq 0x1230
movq %rbx, %rdi
callq 0x1230
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x118d9(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xd91d(%rip), %rdi      # 0xf046
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/fflz4.c
// Function: get_bookmark_file
char *get_bookmark_file(const char *path)
{
    char *buf = NULL, *result = NULL, *p = NULL;
    int len = 0;
    char filep[4096] = {0};
    time_t t1 = 0, t2 = -1;
    struct dirent *entry;
    DIR *dp;

    len = path[strlen(path)-1] == '/'? asprintf(&buf, "%s%s/", path, BOOKMARK) : asprintf(&buf, "%s/%s/", path, BOOKMARK);
    if (!len) FAILED(0, "Not enough memory\n");

    dp = opendir(buf);
    if (!dp) FAILED(0, "Open directory failed at: %s\n", buf);

    while ((entry = readdir(dp))) {
        if (strstr(entry->d_name, "bookmarks")) {
            sprintf(filep, "%s%s", buf, entry->d_name);
            t1 = get_last_modified(filep);
            if (t2 == -1) {
                t2 = t1;
                p = filep;
            }
            else if (t1 > t2) {
                t2 = t1;
                p = filep;
            }
        }
    }

    result = strdup(p);
    if (!result) FAILED(0, "Get bookmark file failed\n");

    closedir(dp);
    free(buf);
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, %r14
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
leaq 0x10(%rsp), %rbx
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c0
movq %r14, %rdi
callq 0x10a0
cmpb $0x2f, -0x1(%r14,%rax)
leaq 0xd95f(%rip), %rax      # 0xf0e1
leaq 0xd95e(%rip), %rsi      # 0xf0e7
cmoveq %rax, %rsi
leaq 0xda5f(%rip), %rcx      # 0xf1f3
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1180
testl %eax, %eax
je 0x1866
movq 0x8(%rsp), %rdi
callq 0x1090
testq %rax, %rax
je 0x187b
movq %rax, %r14
pushq $-0x1
popq %rax
leaq 0xd943(%rip), %r15      # 0xf10c
xorl %ecx, %ecx
movq %rcx, %r13
movq %rax, %r12
movq %r14, %rdi
callq 0x1150
testq %rax, %rax
je 0x182f
movq %rax, %rbp
addq $0x13, %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1210
testq %rax, %rax
je 0x17d1
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
leaq 0xd912(%rip), %rsi      # 0xf116
movq %rbp, %rcx
xorl %eax, %eax
callq 0x11d0
movq %rbx, %rdi
callq 0x19f7
movq %rbx, %rcx
cmpq $-0x1, %r12
je 0x17cb
cmpq %r12, %rax
cmovleq %r12, %rax
cmovgq %rbx, %r13
movq %r13, %rcx
jmp 0x17cb
movq %r13, %rdi
callq 0x1200
testq %rax, %rax
je 0x189a
movq %rax, %rbx
movq %r14, %rdi
callq 0x10d0
movq 0x8(%rsp), %rdi
callq 0x1230
movq %rbx, %rax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1178b(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xd7cf(%rip), %rdi      # 0xf046
pushq $0x12
jmp 0x18ad
movq 0x11776(%rip), %rax     # 0x12ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0xd85d(%rip), %rsi      # 0xf0ee
xorl %eax, %eax
callq 0x1100
jmp 0x18b6
movq 0x11757(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xd870(%rip), %rdi      # 0xf11b
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/fflz4.c
// Function: get_bookmarks
void get_bookmarks(const char *path, const unsigned int flag)
{
    cJSON *json = NULL;
    char *result = NULL;

    result = extract_jsonlz4(path);
    if (!result) FAILED(0, "Failed to read jsonlz4 at: %s\n", path);

    json = cJSON_Parse(result);
    if (!json) goto cleanup;

    if (flag & FLAG_D) {
        char *js = cJSON_Print(json);
        fprintf(stdout, "%s\n", js);
        free(js);
        goto cleanup;
    }

    const cJSON *children = cJSON_GetObjectItemCaseSensitive(json, "children");
    if (!cJSON_IsArray(children)) goto cleanup;

    const cJSON *child = NULL;

    /* get bookmarks toolbar */
    cJSON_ArrayForEach(child, children) {
        const cJSON *root = cJSON_GetObjectItemCaseSensitive(child, "root");
        if (cJSON_IsString(root)) {
            if (!strcmp(root->valuestring, "toolbarFolder")) {
                children = cJSON_GetObjectItemCaseSensitive(child, "children");
                break;
            }
        }
    }

    if (cJSON_IsArray(children))
        print_bookmarks(child, children, flag);
    else
        FAILED(0, "Failed to get bookmarks toolbar\n");

cleanup:
    if (json) cJSON_Delete(json);
    free(result);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
callq 0x1a1d
movq %rax, %rbx
movq %rax, %rdi
callq 0xd2f0
testq %rax, %rax
je 0x19bd
movq %rax, %r14
testb $0x40, %bpl
jne 0x191d
leaq 0xd8be(%rip), %rsi      # 0xf1b2
movq %r14, %rdi
callq 0xda12
movq %rax, %r15
movq %rax, %rdi
callq 0xe6f9
testl %eax, %eax
je 0x19b5
testq %r15, %r15
je 0x194d
movq %r15, %r12
addq $0x10, %r12
jmp 0x1952
movq %r14, %rdi
callq 0xd2f9
movq %rax, %r15
movq 0x11689(%rip), %rax     # 0x12fb8
movq (%rax), %rdi
leaq 0xd875(%rip), %rsi      # 0xf1ae
movq %r15, %rdx
xorl %eax, %eax
callq 0x1100
movq %r15, %rdi
callq 0x1230
jmp 0x19b5
xorl %r12d, %r12d
jmp 0x1956
movq (%r12), %r12
testq %r12, %r12
je 0x199f
leaq 0xd859(%rip), %rsi      # 0xf1bb
movq %r12, %rdi
callq 0xda12
movq %rax, %r13
movq %rax, %rdi
callq 0xcb8e
testl %eax, %eax
je 0x1952
movq 0x20(%r13), %rdi
leaq 0xd83c(%rip), %rsi      # 0xf1c0
callq 0x10f0
testl %eax, %eax
jne 0x1952
leaq 0xd81e(%rip), %rsi      # 0xf1b2
movq %r12, %rdi
callq 0xda12
movq %rax, %r15
movq %r15, %rdi
callq 0xe6f9
testl %eax, %eax
je 0x19d3
movq %r15, %rsi
movl %ebp, %edx
callq 0x1ed5
movq %r14, %rdi
callq 0xcc3e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1230
movq 0x1161e(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xd7ea(%rip), %rdi      # 0xf1ce
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/fflz4.c
// Function: extract_jsonlz4
char *extract_jsonlz4(const char *path)
{
    size_t SIZE = 0;
    unsigned int dst_size;
    const int hdr_size = sizeof(unsigned int);
    char *source = NULL, *result = NULL;

    /* read file */
    /* skip "mozLz40\0" header */
    source = get_file_content(path, "rb", 8, &SIZE);

    memcpy(&dst_size, source, 4);
    if (dst_size > INT_MAX) FAILED(0, "Invalid size in header: 0x%x\n", dst_size);

    result = calloc(dst_size+1, sizeof(char));
    if (!result) FAILED(0, "Not enough memory\n");

    int osize = LZ4_decompress_safe(source + hdr_size, result, SIZE - hdr_size, dst_size);
    if (osize < 0) FAILED(0, "Corrupt input at byte %d\n", -osize);

    free(source);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0xd5ef(%rip), %rsi      # 0xf025
pushq $0x8
popq %rdx
callq 0x1ae4
movl (%rax), %r14d
testl %r14d, %r14d
js 0x1a8c
movq %rax, %rbx
leaq 0x1(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x10e0
testq %rax, %rax
je 0x1aa2
movq %rax, %r15
leaq 0x4(%rbx), %rdi
movl 0x8(%rsp), %edx
addl $-0x4, %edx
movq %rax, %rsi
movl %r14d, %ecx
callq 0x9361
testl %eax, %eax
js 0x1ac0
movq %rbx, %rdi
callq 0x1230
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x11565(%rip), %rax     # 0x12ff8
movq (%rax), %rdi
leaq 0xd58b(%rip), %rsi      # 0xf028
movl %r14d, %edx
jmp 0x1ad5
movq 0x1154f(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xd593(%rip), %rdi      # 0xf046
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
jmp 0x1adc
movq 0x11531(%rip), %rcx     # 0x12ff8
movq (%rcx), %rdi
negl %eax
leaq 0xd586(%rip), %rsi      # 0xf059
movl %eax, %edx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/fflz4.c
// Function: get_file_content
char *get_file_content(const char *path, const char *rw, const size_t offset, size_t *size)
{
    FILE *fptr;
    size_t SIZE = 0, sz = 0;
    char *result = NULL;

    fptr = fopen(path, rw);
    if (!fptr) FAILED(0, "File not found at: %s", path);

    fseek(fptr, 0, SEEK_END);
    SIZE = ftell(fptr);
    fseek(fptr, offset, SEEK_SET);
    SIZE -= offset;

    result = calloc(SIZE+1, sizeof(char));
    if (!result) FAILED(0, "Not enough memory\n");

    sz = fread(result, 1, SIZE, fptr);
    if (sz != SIZE) FAILED(0, "File reading failed\n");

    fclose(fptr);

    *size = SIZE;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r15
callq 0x11a0
testq %rax, %rax
je 0x1b6e
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1170
movq %r14, %rdi
callq 0x1110
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1170
subq %r12, %r15
leaq 0x1(%r15), %rdi
pushq $0x1
popq %rsi
callq 0x10e0
testq %rax, %rax
je 0x1b8b
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1060
cmpq %r15, %rax
jne 0x1ba0
movq %r14, %rdi
callq 0x1080
movq %r15, (%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x11483(%rip), %rax     # 0x12ff8
movq (%rax), %rdi
leaq 0xd5b6(%rip), %rsi      # 0xf135
movq %r15, %rdx
xorl %eax, %eax
callq 0x1100
jmp 0x1bbc
movq 0x11466(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xd4aa(%rip), %rdi      # 0xf046
pushq $0x12
jmp 0x1bb3
movq 0x11451(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xd59a(%rip), %rdi      # 0xf14b
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/fflz4.c
// Function: print_bookmarks
void print_bookmarks(const cJSON *child, const cJSON *children, const unsigned int flag)
{
    cJSON_ArrayForEach(child, children) {
        const cJSON *url = cJSON_GetObjectItemCaseSensitive(child, "uri");
        const cJSON *deep = cJSON_GetObjectItemCaseSensitive(child, "children");

        if (cJSON_IsString(url)) {
            const cJSON *title = cJSON_GetObjectItemCaseSensitive(child, "title");

            if (((flag & (FLAG_T | FLAG_U)) == 0) && cJSON_IsString(title))
                fprintf(stdout, "%s\n%s\n\n", title->valuestring, url->valuestring);
            if (flag & FLAG_U)
                fprintf(stdout, "%s\n", url->valuestring);
            if ((flag & FLAG_T) && cJSON_IsString(title))
                fprintf(stdout, "%s\n", title->valuestring);
        }
        else if (cJSON_IsArray(deep)) {
            print_bookmarks(child, deep, flag);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
testq %rsi, %rsi
je 0x1eed
movq 0x10(%rsi), %r14
jmp 0x1ef0
xorl %r14d, %r14d
leaq 0xd2f8(%rip), %r15      # 0xf1ef
leaq 0xd2b4(%rip), %r12      # 0xf1b2
testq %r14, %r14
je 0x1fe4
movq %r14, %rdi
movq %r15, %rsi
callq 0xda12
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0xda12
movq %rax, %rbp
movq %r13, %rdi
callq 0xcb8e
testl %eax, %eax
je 0x1fc6
movq %r14, %rdi
leaq 0xd25c(%rip), %rsi      # 0xf199
callq 0xda12
movq %rax, %rbp
testb $0x6, %bl
jne 0x1f76
movq %rbp, %rdi
callq 0xcb8e
testl %eax, %eax
je 0x1f76
movq 0x1105b(%rip), %rax     # 0x12fb8
movq (%rax), %rdi
movq 0x20(%rbp), %rdx
movq 0x20(%r13), %rcx
leaq 0xd234(%rip), %rsi      # 0xf1a3
xorl %eax, %eax
callq 0x1100
testb $0x2, %bl
je 0x1f97
movq 0x11036(%rip), %rax     # 0x12fb8
movq (%rax), %rdi
movq 0x20(%r13), %rdx
leaq 0xd21e(%rip), %rsi      # 0xf1ae
xorl %eax, %eax
callq 0x1100
testb $0x4, %bl
je 0x1fdc
movq %rbp, %rdi
callq 0xcb8e
testl %eax, %eax
je 0x1fdc
movq 0x11009(%rip), %rax     # 0x12fb8
movq (%rax), %rdi
movq 0x20(%rbp), %rdx
leaq 0xd1f1(%rip), %rsi      # 0xf1ae
xorl %eax, %eax
callq 0x1100
jmp 0x1fdc
movq %rbp, %rdi
callq 0xe6f9
testl %eax, %eax
je 0x1fdc
movq %rbp, %rsi
movl %ebx, %edx
callq 0x1ed5
movq (%r14), %r14
jmp 0x1efe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_loadDict
int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
{
    LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse;
    const tableType_t tableType = byU32;
    const BYTE* p = (const BYTE*)dictionary;
    const BYTE* const dictEnd = p + dictSize;
    const BYTE* base;

    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);

    /* It's necessary to reset the context,
     * and not just continue it with prepareTable()
     * to avoid any risk of generating overflowing matchIndex
     * when compressing using this dictionary */
    LZ4_resetStream(LZ4_dict);

    /* We always increment the offset by 64 KB, since, if the dict is longer,
     * we truncate it to the last 64k, and if it's shorter, we still want to
     * advance by a whole window length so we can provide the guarantee that
     * there are only valid offsets in the window, which allows an optimization
     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
     * dictionary isn't a full 64k. */
    dict->currentOffset += 64 KB;

    if (dictSize < (int)HASH_UNIT) {
        return 0;
    }

    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
    base = dictEnd - dict->currentOffset;
    dict->dictionary = p;
    dict->dictSize = (U32)(dictEnd - p);
    dict->tableType = tableType;

    while (p <= dictEnd-HASH_UNIT) {
        LZ4_putPosition(p, dict->hashTable, tableType, base);
        p+=3;
    }

    return (int)dict->dictSize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x4020, %edx           # imm = 0x4020
xorl %esi, %esi
callq 0x10c0
movl $0x10000, 0x4000(%rbx)  # imm = 0x10000
cmpl $0x8, %ebp
jge 0x5e80
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %esi
cmpl $0x10001, %ebp          # imm = 0x10001
leaq -0x10000(%r15,%rsi), %rax
cmovbq %r15, %rax
leaq (%r15,%rsi), %r14
movq %rax, 0x4008(%rbx)
subl %eax, %r14d
movl %r14d, 0x4018(%rbx)
movw $0x2, 0x4006(%rbx)
leaq (%r15,%rsi), %rcx
addq $-0x8, %rcx
cmpq $0x10001, %rsi          # imm = 0x10001
movl $0x10000, %edx          # imm = 0x10000
cmovaeq %rsi, %rdx
subl %ebp, %edx
movabsq $-0x30e4432345000000, %rsi # imm = 0xCF1BBCDCBB000000
cmpq %rcx, %rax
ja 0x5e72
movq (%rax), %rdi
imulq %rsi, %rdi
shrq $0x34, %rdi
movl %edx, (%rbx,%rdi,4)
addq $0x3, %rax
addl $0x3, %edx
jmp 0x5ed6
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_renormDictT
static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
{
    assert(nextSize >= 0);
    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
        /* rescale hash table */
        U32 const delta = LZ4_dict->currentOffset - 64 KB;
        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
        int i;
        DEBUGLOG(4, "LZ4_renormDictT");
        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
            else LZ4_dict->hashTable[i] -= delta;
        }
        LZ4_dict->currentOffset = 64 KB;
        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
    }
}

// Assembly:
movl 0x4000(%rdi), %ecx
addl %ecx, %esi
cmpl $0x80000001, %esi       # imm = 0x80000001
jb 0x8651
addl $0xffff0000, %ecx       # imm = 0xFFFF0000
movq 0x4008(%rdi), %rax
movl 0x4018(%rdi), %edx
xorl %esi, %esi
xorl %r8d, %r8d
cmpq $0x1000, %r8            # imm = 0x1000
je 0x861b
movl (%rdi,%r8,4), %r9d
subl %ecx, %r9d
cmovbl %esi, %r9d
movl %r9d, (%rdi,%r8,4)
incq %r8
jmp 0x85fe
addq %rdx, %rax
movl $0x10000, 0x4000(%rdi)  # imm = 0x10000
movl 0x4018(%rdi), %ecx
cmpl $0x10001, %ecx          # imm = 0x10001
jb 0x8645
movl $0x10000, 0x4018(%rdi)  # imm = 0x10000
movl $0x10000, %ecx          # imm = 0x10000
movl %ecx, %ecx
subq %rcx, %rax
movq %rax, 0x4008(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_setStreamDecode
int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
{
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
    lz4sd->prefixSize = (size_t) dictSize;
    lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
    lz4sd->externalDict = NULL;
    lz4sd->extDictSize  = 0;
    return 1;
}

// Assembly:
movslq %edx, %rax
movq %rax, 0x18(%rdi)
addq %rax, %rsi
movq %rsi, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/Aethlas[P]fflz4/./lib/lz4/lz4.c
// Function: LZ4_memcpy_using_offset
LZ4_FORCE_O2_INLINE_GCC_PPC64LE void
LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
{
    BYTE v[8];

    assert(dstEnd >= dstPtr + MINMATCH);
    LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */

    switch(offset) {
    case 1:
        memset(v, *srcPtr, 8);
        break;
    case 2:
        memcpy(v, srcPtr, 2);
        memcpy(&v[2], srcPtr, 2);
        memcpy(&v[4], &v[0], 4);
        break;
    case 4:
        memcpy(v, srcPtr, 4);
        memcpy(&v[4], srcPtr, 4);
        break;
    default:
        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
        return;
    }

    memcpy(dstPtr, v, 8);
    dstPtr += 8;
    while (dstPtr < dstEnd) {
        memcpy(dstPtr, v, 8);
        dstPtr += 8;
    }
}

// Assembly:
andl $0x0, (%rdi)
cmpq $0x4, %rcx
je 0xcaed
cmpq $0x2, %rcx
je 0xcae1
cmpq $0x1, %rcx
jne 0xcb02
movzbl (%rsi), %eax
imull $0x1010101, %eax, %eax  # imm = 0x1010101
jmp 0xcaef
movzwl (%rsi), %ecx
movl %ecx, %eax
shll $0x10, %eax
orl %ecx, %eax
jmp 0xcaef
movl (%rsi), %eax
movl %eax, (%rdi)
addq $0x4, %rdi
movl %eax, (%rdi)
addq $0x4, %rdi
cmpq %rdx, %rdi
jb 0xcaef
jmp 0xcb68
cmpq $0x7, %rcx
ja 0xcb44
movb (%rsi), %al
movb %al, (%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
movb 0x2(%rsi), %al
movb %al, 0x2(%rdi)
movb 0x3(%rsi), %al
movb %al, 0x3(%rdi)
leaq 0x284b(%rip), %rax      # 0xf370
movl (%rax,%rcx,4), %r8d
leaq (%rsi,%r8), %rax
movl (%rsi,%r8), %esi
movl %esi, 0x4(%rdi)
leaq 0x2855(%rip), %rsi      # 0xf390
movslq (%rsi,%rcx,4), %rcx
subq %rcx, %rax
jmp 0xcb51
movq (%rsi), %rax
movq %rax, (%rdi)
addq $0x8, %rsi
movq %rsi, %rax
addq $0x8, %rdi
movq (%rax), %rcx
movq %rcx, (%rdi)
addq $0x8, %rdi
addq $0x8, %rax
cmpq %rdx, %rdi
jb 0xcb55
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_libjpeg.c
// Function: oil_libjpeg_init
int oil_libjpeg_init(struct oil_libjpeg *ol,
	struct jpeg_decompress_struct *dinfo, int out_width, int out_height)
{
	int ret;
	enum oil_colorspace cs;

	ol->dinfo = dinfo;

	cs = jpeg_cs_to_oil(dinfo->out_color_space);
	if (cs == OIL_CS_UNKNOWN) {
		return -1;
	}

	ol->inbuf = malloc(dinfo->output_width * dinfo->output_components);
	if (!ol->inbuf) {
		return -2;
	}

	ret = oil_scale_init(&ol->os, dinfo->output_height, out_height,
		dinfo->output_width, out_width, cs);
	if (ret!=0) {
		free(ol->inbuf);
		return ret;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x58(%rdi)
movl 0x40(%rsi), %edi
callq 0x429d
testl %eax, %eax
je 0x4281
movl %eax, %r12d
movl 0x88(%r15), %r13d
movl 0x94(%r15), %edi
imull %r13d, %edi
callq 0x20d0
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x4285
movl 0x8c(%r15), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
movl %r12d, %r9d
callq 0x262c
testl %eax, %eax
je 0x4299
movl %eax, %ebp
movq 0x60(%rbx), %rdi
callq 0x21a0
jmp 0x4288
pushq $-0x1
jmp 0x4287
pushq $-0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x4288
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_libjpeg.c
// Function: oil_libjpeg_read_scanline
void oil_libjpeg_read_scanline(struct oil_libjpeg *ol, unsigned char *outbuf)
{
	while (oil_scale_slots(&ol->os)) {
		jpeg_read_scanlines(ol->dinfo, &ol->inbuf, 1);
		oil_scale_in(&ol->os, ol->inbuf);
	}
	oil_scale_out(&ol->os, outbuf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x60(%rdi), %r15
pushq $0x1
popq %rbp
movq %r14, %rdi
callq 0x2b69
testl %eax, %eax
je 0x4305
movq 0x58(%r14), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2280
movq 0x60(%r14), %rsi
movq %r14, %rdi
callq 0x2b9b
jmp 0x42dd
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35de
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_libpng.c
// Function: oil_libpng_init
int oil_libpng_init(struct oil_libpng *ol, png_structp rpng, png_infop rinfo,
	int out_width, int out_height)
{
	int ret, in_width, in_height, buf_len;
	enum oil_colorspace cs;

	ol->rpng = rpng;
	ol->rinfo = rinfo;
	ol->in_vpos = 0;
	ol->inbuf = NULL;
	ol->inimage = NULL;

	cs = png_cs_to_oil(png_get_color_type(rpng, rinfo));
	if (cs == OIL_CS_UNKNOWN) {
		return -1;
	}

	in_width = png_get_image_width(rpng, rinfo);
	in_height = png_get_image_height(rpng, rinfo);
	ret = oil_scale_init(&ol->os, in_height, out_height, in_width,
		out_width, cs);
	if (ret!=0) {
		free(ol->inbuf);
		return ret;
	}

	buf_len = png_get_rowbytes(rpng, rinfo);
	switch (png_get_interlace_type(rpng, rinfo)) {
	case PNG_INTERLACE_NONE:
		ol->inbuf = malloc(buf_len);
		if (!ol->inbuf) {
			oil_scale_free(&ol->os);
			return -2;
		}
		break;
	case PNG_INTERLACE_ADAM7:
		ol->inimage = alloc_full_image_buf(in_height, buf_len);
		if (!ol->inimage) {
			oil_scale_free(&ol->os);
			return -2;
		}
		png_read_image(rpng, ol->inimage);
		break;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x58(%rdi)
movq %rdx, 0x60(%rdi)
andl $0x0, 0x68(%rdi)
movl %r8d, %r13d
movl %ecx, %r12d
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2130
movzbl %al, %edi
callq 0x44d1
testl %eax, %eax
je 0x43d9
movl %eax, %ebp
leaq 0x70(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2120
movl %r12d, 0xc(%rsp)
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f0
movl %r13d, %edx
movl %eax, %r13d
movq %rbx, %rdi
movl %eax, %esi
movl %r12d, %ecx
movl 0xc(%rsp), %r8d
movl %ebp, %r9d
callq 0x262c
testl %eax, %eax
je 0x43ef
movl %eax, %r12d
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x21a0
jmp 0x43dd
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, %r12d
movq 0x10(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x21f0
cmpb $0x1, %al
je 0x4434
movzbl %al, %eax
xorl %r12d, %r12d
testl %eax, %eax
jne 0x43dd
movslq %r13d, %rdi
callq 0x20d0
movq %rax, (%rbp)
testq %rax, %rax
jne 0x43dd
jmp 0x44c2
movl %r12d, %ebp
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x20d0
testq %rax, %rax
je 0x44bd
movq %rax, %r15
movslq %r13d, %r12
movl %ebp, %eax
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
negq %rbp
pushq $-0x1
popq %r13
movq %rbp, %rax
addq %r13, %rax
cmpq $-0x1, %rax
je 0x4481
movq %r12, %rdi
callq 0x20d0
movq %rax, 0x8(%r15,%r13,8)
testq %rax, %rax
je 0x4498
incq %r13
jmp 0x445e
movq %r15, 0x78(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2300
xorl %r12d, %r12d
jmp 0x43dd
xorl %r14d, %r14d
testq %r13, %r13
cmovleq %r14, %r13
cmpq %r14, %r13
je 0x44b5
movq (%r15,%r14,8), %rdi
callq 0x21a0
incq %r14
jmp 0x44a2
movq %r15, %rdi
callq 0x21a0
andq $0x0, 0x78(%rbx)
movq %rbx, %rdi
callq 0x28cb
pushq $-0x2
jmp 0x43db
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_libpng.c
// Function: oil_libpng_free
void oil_libpng_free(struct oil_libpng *ol)
{
	if (ol->inbuf) {
		free(ol->inbuf);
	}
	if (ol->inimage) {
		free_full_image_buf(ol->inimage, ol->os.in_height);
	}
	oil_scale_free(&ol->os);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
callq 0x21a0
movq 0x78(%rbx), %r14
testq %r14, %r14
je 0x452d
movl (%rbx), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x4525
movq (%r14,%r12,8), %rdi
callq 0x21a0
incq %r12
jmp 0x4512
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28cb
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_libpng.c
// Function: oil_libpng_read_scanline
void oil_libpng_read_scanline(struct oil_libpng *ol, unsigned char *outbuf)
{
	switch (png_get_interlace_type(ol->rpng, ol->rinfo)) {
	case PNG_INTERLACE_NONE:
		read_scanline(ol);
		break;
	case PNG_INTERLACE_ADAM7:
		read_scanline_interlaced(ol);
		break;
	}
	oil_scale_out(&ol->os, outbuf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rdi
movq 0x60(%r14), %rsi
callq 0x21f0
cmpb $0x1, %al
je 0x45a8
movzbl %al, %eax
testl %eax, %eax
je 0x457f
jmp 0x45b4
movq 0x58(%r14), %rdi
movq 0x70(%r14), %rsi
xorl %edx, %edx
callq 0x2060
movq 0x70(%r14), %rsi
movq %r14, %rdi
callq 0x2b9b
movq %r14, %rdi
callq 0x2b69
testl %eax, %eax
jne 0x4564
jmp 0x45b4
movq 0x78(%r14), %rax
movslq 0x68(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x68(%r14)
movq (%rax,%rcx,8), %rsi
movq %r14, %rdi
callq 0x2b9b
movq %r14, %rdi
callq 0x2b69
testl %eax, %eax
jne 0x458d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35de
nop
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_init
int mtgp64_init(mtgp64_ref_t *mtgp64,
		const mtgp64_params_ref_t *para, uint64_t seed) {
    int i;
    int size = para->mexp / 64 + 1;
    uint64_t hidden_seed;
    uint64_t tmp;
    mtgp64_status_ref_t *st;

    st = (mtgp64_status_ref_t *)malloc(sizeof(mtgp64_status_ref_t)
				     + sizeof(uint64_t) * size);
    if (st == NULL) {
	return -1;
    }
    hidden_seed = para->tbl[2] ^ (para->tbl[3] << 16);
    tmp = hidden_seed >> 32;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(st->array, tmp & 0xff, sizeof(uint64_t) * size);
    mtgp64->params = *para;
    mtgp64->status = st;
    st->size = size;
    st->idx = size - 1;
    st->array[0] = seed;
    st->array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	st->array[i] ^= UINT64_C(6364136223846793005)
	    * (st->array[i - 1]
	       ^ (st->array[i - 1] >> 62)) + i;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl (%rsi), %eax
pushq $0x40
popq %rcx
cltd
idivl %ecx
movslq %eax, %r13
leaq 0x10(,%r13,8), %rdi
callq 0x10d0
testq %rax, %rax
je 0x12b4
movq %rax, %r14
leal 0x1(%r13), %eax
movl %eax, 0x4(%rsp)
leaq 0x8(,%r13,8), %rdx
movq 0x28(%r12), %rbp
shlq $0x10, %rbp
xorq 0x20(%r12), %rbp
movq %rbp, %rax
shrq $0x20, %rax
movq %rbp, %rcx
shrq $0x30, %rcx
addq %rax, %rcx
movq %rcx, %rsi
shrq $0x8, %rsi
addl %ecx, %esi
movq %r14, %rdi
addq $0x8, %rdi
callq 0x1090
pushq $0xe
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, 0x70(%r15)
movl 0x4(%rsp), %eax
movl %eax, (%r14)
movl %r13d, 0x4(%r14)
movq %rbx, 0x8(%r14)
movq %rbp, 0x10(%r14)
pushq $0x1
popq %rax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
cmpq %r13, %rax
jg 0x12b0
movq %rbx, %rdx
shrq $0x3e, %rdx
xorq %rbx, %rdx
imulq %rcx, %rdx
addq %rax, %rdx
xorq 0x8(%r14,%rax,8), %rdx
movq %rdx, 0x8(%r14,%rax,8)
incq %rax
movq %rdx, %rbx
jmp 0x1288
xorl %eax, %eax
jmp 0x12b7
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_print_idstring
void mtgp64_print_idstring(const mtgp64_ref_t *mtgp64, FILE *fp) {
    int i;
    fprintf(fp, "mtgp64:%d:", mtgp64->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp64->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x740(%rip), %rsi       # 0x2018
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
pushq $-0x14
popq %r12
leaq 0x736(%rip), %r15       # 0x2023
testq %r12, %r12
je 0x190a
movzbl 0x6c(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
jmp 0x18ed
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_genrand_uint64
static void next_state(mtgp64_ref_t *mtgp64) {
    uint64_t *array = mtgp64->status->array;
    int idx;
    int size = mtgp64->status->size;
    uint64_t x;
    uint64_t y;
    uint64_t r;
    uint32_t xh;
    uint32_t xl;
    uint32_t yh;
    uint32_t yl;

    mtgp64->status->idx += 1;
    if (mtgp64->status->idx >= size) {
	mtgp64->status->idx = 0;
    }
    idx = mtgp64->status->idx;
    x = (array[idx] & mtgp64->params.mask) ^ array[(idx + 1) % size];
    y = array[(idx + mtgp64->params.pos) % size];
    xh = (uint32_t)(x >> 32);
    xl = (uint32_t)(x & 0xffffffffU);
    yh = (uint32_t)(y >> 32);
    yl = (uint32_t)(y & 0xffffffffU);
    xh ^= xh << mtgp64->params.sh1;
    xl ^= xl << mtgp64->params.sh1;
    yh = xl ^ (yh >> mtgp64->params.sh2);
    yl = xh ^ (yl >> mtgp64->params.sh2);
    r = ((uint64_t)yh << 32) | yl;
    if (yl & 1) {
	r ^= mtgp64->params.tbl[0];
    }
    if (yl & 2) {
	r ^= mtgp64->params.tbl[1];
    }
    if (yl & 4) {
	r ^= mtgp64->params.tbl[2];
    }
    if (yl & 8) {
	r ^= mtgp64->params.tbl[3];
    }
    array[idx] = r;
}

// Assembly:
pushq %rbp
pushq %rbx
movq 0x70(%rdi), %rsi
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
incl %eax
xorl %edx, %edx
cmpl %ecx, %eax
cmovll %eax, %edx
movl %edx, 0x4(%rsi)
movslq %edx, %r8
movq 0x50(%rdi), %r10
andq 0x8(%rsi,%r8,8), %r10
leal 0x1(%r8), %eax
cltd
idivl %ecx
movslq %edx, %rax
xorq 0x8(%rsi,%rax,8), %r10
movl 0x4(%rdi), %r9d
leal (%r9,%r8), %eax
cltd
idivl %ecx
movslq %edx, %rax
movq 0x8(%rsi,%rax,8), %rax
movq %r10, %rdx
shrq $0x20, %rdx
movb 0x8(%rdi), %cl
movl %edx, %r11d
shll %cl, %r11d
movq %rax, %rbx
shrq $0x20, %rbx
movl %r10d, %ebp
shll %cl, %ebp
movb 0xc(%rdi), %cl
shrl %cl, %ebx
xorl %ebp, %ebx
xorl %r10d, %ebx
shrl %cl, %eax
xorl %edx, %eax
xorl %r11d, %eax
shlq $0x20, %rbx
leaq (%rax,%rbx), %rcx
testb $0x1, %al
je 0x19a2
xorq 0x10(%rdi), %rcx
testb $0x2, %al
je 0x19aa
xorq 0x18(%rdi), %rcx
testb $0x4, %al
je 0x19b2
xorq 0x20(%rdi), %rcx
testb $0x8, %al
je 0x19ba
xorq 0x28(%rdi), %rcx
movq %rcx, 0x8(%rsi,%r8,8)
movq 0x70(%rdi), %rsi
movslq 0x4(%rsi), %rax
movq 0x8(%rsi,%rax,8), %rcx
addl %r9d, %eax
decl %eax
cltd
idivl (%rsi)
movslq %edx, %rax
movq 0x8(%rsi,%rax,8), %rax
movq %rax, %rdx
shrq $0x10, %rdx
xorq %rax, %rdx
movq %rdx, %rax
shrq $0x8, %rax
xorq %rdx, %rax
testb $0x1, %al
je 0x19f8
xorq 0x30(%rdi), %rcx
testb $0x2, %al
je 0x1a00
xorq 0x38(%rdi), %rcx
testb $0x4, %al
je 0x1a08
xorq 0x40(%rdi), %rcx
testb $0x8, %al
je 0x1a10
xorq 0x48(%rdi), %rcx
movq %rcx, %rax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_genrand_close1_open2
double mtgp64_genrand_close1_open2(mtgp64_ref_t *mtgp64) {
    union {
	uint64_t u;
	double d;
    } x;
    x.u = mtgp64_genrand_uint64(mtgp64);
    x.u = (x.u >> 12) | UINT64_C(0x3ff0000000000000);
    return x.d;
}

// Assembly:
pushq %rax
callq 0x1920
shrq $0xc, %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
orq %rax, %rcx
movq %rcx, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: mtgp64_genrand_open_open
double mtgp64_genrand_open_open(mtgp64_ref_t *mtgp64) {
    union {
	uint64_t u;
	double d;
    } x;
    x.u = mtgp64_genrand_uint64(mtgp64);
    x.u = (x.u >> 12) | UINT64_C(0x3ff0000000000001);
    return x.d - 1.0;
}

// Assembly:
pushq %rax
callq 0x1920
shrq $0xc, %rax
movabsq $0x3ff0000000000001, %rcx # imm = 0x3FF0000000000001
orq %rax, %rcx
movq %rcx, %xmm0
addsd 0x588(%rip), %xmm0      # 0x2008
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_uint64
void print_uint64(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%016"PRIx64" ", mtgp64_genrand_uint64(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebx
pushq $0x2
popq %r13
pushq $0x3
popq %rbp
xorl %r12d, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
subl $0x1, %ebx
jb 0x1ae4
leal (%rax,%rax,2), %r15d
addl %r13d, %r15d
movq %r14, %rdi
callq 0x1920
leaq 0x563(%rip), %rdi       # 0x2028
movq %rax, %rsi
xorl %eax, %eax
callq 0x1080
testl %r15d, %r15d
jne 0x1adc
pushq $0xa
popq %rdi
callq 0x1040
incl %r12d
decl %r13d
jmp 0x1aa3
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_close1_open2
void print_close1_open2(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_close1_open2(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %ebx
pushq $0x2
popq %r13
pushq $0x3
popq %r12
movl %ebp, %eax
xorl %edx, %edx
divl %r12d
subl $0x1, %ebx
jb 0x1b56
leal (%rax,%rax,2), %r15d
addl %r13d, %r15d
movq %r14, %rdi
callq 0x1a16
leaq 0x4f5(%rip), %rdi       # 0x2030
movb $0x1, %al
callq 0x1080
testl %r15d, %r15d
jne 0x1b4f
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %r13d
jmp 0x1b19
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_close_open
void print_close_open(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_close_open(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %ebx
pushq $0x2
popq %r13
pushq $0x3
popq %r12
movl %ebp, %eax
xorl %edx, %edx
divl %r12d
subl $0x1, %ebx
jb 0x1bc8
leal (%rax,%rax,2), %r15d
addl %r13d, %r15d
movq %r14, %rdi
callq 0x1a34
leaq 0x483(%rip), %rdi       # 0x2030
movb $0x1, %al
callq 0x1080
testl %r15d, %r15d
jne 0x1bc1
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %r13d
jmp 0x1b8b
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_open_close
void print_open_close(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_open_close(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %ebx
pushq $0x2
popq %r13
pushq $0x3
popq %r12
movl %ebp, %eax
xorl %edx, %edx
divl %r12d
subl $0x1, %ebx
jb 0x1c3a
leal (%rax,%rax,2), %r15d
addl %r13d, %r15d
movq %r14, %rdi
callq 0x1a44
leaq 0x411(%rip), %rdi       # 0x2030
movb $0x1, %al
callq 0x1080
testl %r15d, %r15d
jne 0x1c33
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %r13d
jmp 0x1bfd
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp64-ref.c
// Function: print_open_open
void print_open_open(mtgp64_ref_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_open_open(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %ebx
pushq $0x2
popq %r13
pushq $0x3
popq %r12
movl %ebp, %eax
xorl %edx, %edx
divl %r12d
subl $0x1, %ebx
jb 0x1cac
leal (%rax,%rax,2), %r15d
addl %r13d, %r15d
movq %r14, %rdi
callq 0x1a5c
leaq 0x39f(%rip), %rdi       # 0x2030
movb $0x1, %al
callq 0x1080
testl %r15d, %r15d
jne 0x1ca5
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %r13d
jmp 0x1c6f
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread1
void *thread1(void *arg) {
	while(run == 1) {
		dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);

		c1++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x28d3(%rip), %rbx      # 0x4108
cmpq $0x1, 0x285b(%rip)      # 0x4098
jne 0x185f
movq %rbx, %rdi
callq 0x16bb
incq 0x2892(%rip)            # 0x40e0
movq %rbx, %rdi
callq 0x16e7
incq 0x288b(%rip)            # 0x40e8
jmp 0x1835
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread2
void *thread2(void *arg) {
	while(run == 1) {
        dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);
		c2++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2893(%rip), %rbx      # 0x4108
cmpq $0x1, 0x281b(%rip)      # 0x4098
jne 0x189f
movq %rbx, %rdi
callq 0x16bb
incq 0x2852(%rip)            # 0x40e0
movq %rbx, %rdi
callq 0x16e7
incq 0x2853(%rip)            # 0x40f0
jmp 0x1875
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread3
void *thread3(void *arg) {
	while(run == 1) {
        dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);
		c3++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2853(%rip), %rbx      # 0x4108
cmpq $0x1, 0x27db(%rip)      # 0x4098
jne 0x18df
movq %rbx, %rdi
callq 0x16bb
incq 0x2812(%rip)            # 0x40e0
movq %rbx, %rdi
callq 0x16e7
incq 0x281b(%rip)            # 0x40f8
jmp 0x18b5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: thread4
void *thread4(void *arg) {
	while(run == 1) {
        dthread_spin_lock(&lock);
        c++;
		dthread_spin_unlock(&lock);
		c4++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2813(%rip), %rbx      # 0x4108
cmpq $0x1, 0x279b(%rip)      # 0x4098
jne 0x191f
movq %rbx, %rdi
callq 0x16bb
incq 0x27d2(%rip)            # 0x40e0
movq %rbx, %rdi
callq 0x16e7
incq 0x27e3(%rip)            # 0x4100
jmp 0x18f5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deepika9294[P]Threading-Library/many-one/test/spin.c
// Function: main
int main() {
	dthread_t th1, th2, th3, th4; 
    dthread_init();
	dthread_spin_init(&lock);
    printf("\n\n");

	dthread_create(&th1, thread1, NULL);
	dthread_create(&th2, thread2, NULL);
	dthread_create(&th3, thread3, NULL);
	dthread_create(&th4, thread4, NULL);

	for(int i = 0; i < 100000000; i++);
	run = 0;
	dthread_join(th1, NULL);
	dthread_join(th2, NULL);
	dthread_join(th3, NULL);
	dthread_join(th4, NULL);


	if(c == c1 + c2 + c3 + c4) {
		printf(GREEN "**PASSED**: Spin lock test for race problem between 4 threads\n" NONE);
	}
	else {
		printf(RED "**FAILED**: Spin lock test for race problem between 4 threads\n" NONE);
	}
    // printf("\n%ld %ld %ld %ld %ld %ld\n", c, c1+c2+c3+c4 , c1, c2, c3, c4);

	
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
callq 0x120c
leaq 0x27c5(%rip), %rdi      # 0x4108
callq 0x16b0
leaq 0x77a(%rip), %rdi       # 0x20c9
callq 0x1050
leaq -0x133(%rip), %rsi      # 0x1828
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x14ba
leaq -0x108(%rip), %rsi      # 0x1868
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x14ba
leaq -0xdd(%rip), %rsi       # 0x18a8
leaq -0x30(%rbp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x14ba
leaq -0xb2(%rip), %rsi       # 0x18e8
leaq -0x28(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x14ba
andq $0x0, 0x26e8(%rip)      # 0x4098
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x15d3
movq (%r14), %rdi
xorl %esi, %esi
callq 0x15d3
movq (%r15), %rdi
xorl %esi, %esi
callq 0x15d3
movq (%r12), %rdi
xorl %esi, %esi
callq 0x15d3
movq 0x2710(%rip), %rax      # 0x40f0
addq 0x2701(%rip), %rax      # 0x40e8
addq 0x270a(%rip), %rax      # 0x40f8
addq 0x270b(%rip), %rax      # 0x4100
cmpq %rax, 0x26e4(%rip)      # 0x40e0
leaq 0x62e(%rip), %rax       # 0x2031
leaq 0x673(%rip), %rdi       # 0x207d
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x1080
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O2/hoomanist[P]carrot/mv.c
// Function: main
int
main(int argc, char **argv)
{
	int c;
	FILE *fp;
	FILE *dest;

	fp = fopen(argv[1], "r");
	dest = fopen(argv[2], "w");
	if(fp == NULL) {
                perror("Error in opening file");
        } do {
                c = fgetc(fp);
                if( feof(fp) ) {
                        break ;
                }
                fputc(c, dest);
        } while(1);
        fclose(fp);
	int delete = remove(argv[1]);
	if (!delete)
		return 0;
	else
		printf("permission denied ! \n");

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0xe43(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, %r14
movq 0x10(%rbx), %rdi
leaq 0xe32(%rip), %rsi       # 0x2006
callq 0x1090
movq %rax, %r15
testq %r14, %r14
jne 0x11f9
leaq 0xe20(%rip), %rdi       # 0x2008
callq 0x10a0
jmp 0x11f9
movl %ebp, %edi
movq %r15, %rsi
callq 0x1070
movq %r14, %rdi
callq 0x1060
movl %eax, %ebp
movq %r14, %rdi
callq 0x1080
testl %eax, %eax
je 0x11ef
movq %r14, %rdi
callq 0x1050
movq 0x8(%rbx), %rdi
callq 0x1030
testl %eax, %eax
je 0x1230
leaq 0xdf3(%rip), %rdi       # 0x201e
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpc_err_file
static mpc_err_t *mpc_err_file(const char *filename, const char *failure) {
  mpc_err_t *x;
  x = malloc(sizeof(mpc_err_t));
  x->filename = malloc(strlen(filename) + 1);
  strcpy(x->filename, filename);
  x->state = mpc_state_new();
  x->expected_num = 0;
  x->expected = NULL;
  x->failure = malloc(strlen(failure) + 1);
  strcpy(x->failure, failure);
  x->recieved = ' ';
  return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x21a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x20c0
leaq 0x1(%rax), %rdi
callq 0x21a0
movq %rax, 0x20(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2060
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x30(%rbx)
pushq $0x15
popq %rdi
callq 0x21a0
movq %rax, 0x28(%rbx)
movups 0xcab2(%rip), %xmm0     # 0x102f6
movups %xmm0, (%rax)
movabsq $0x21656c6966206e, %rcx # imm = 0x21656C6966206E
movq %rcx, 0xd(%rax)
movb $0x20, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcf_re_repeat
static mpc_val_t *mpcf_re_repeat(int n, mpc_val_t **xs) {
  int num;
  (void) n;
  if (xs[1] == NULL) { return xs[0]; }
  if (strcmp(xs[1], "*") == 0) { free(xs[1]); return mpc_many(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "+") == 0) { free(xs[1]); return mpc_many1(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "?") == 0) { free(xs[1]); return mpc_maybe_lift(xs[0], mpcf_ctor_str); }
  num = *(int*)xs[1];
  free(xs[1]);
  
  return mpc_count(num, mpcf_strfold, xs[0], free);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x536e
movzbl (%rdi), %eax
cmpl $0x3f, %eax
je 0x5398
cmpl $0x2b, %eax
je 0x5378
cmpl $0x2a, %eax
jne 0x539e
cmpb $0x0, 0x1(%rdi)
jne 0x539e
callq 0x22c0
movq (%rbx), %rsi
leaq -0xd97(%rip), %rdi      # 0x45cc
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x41da
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpb $0x0, 0x1(%rdi)
jne 0x539e
callq 0x22c0
movq (%rbx), %rsi
leaq -0xdc1(%rip), %rdi      # 0x45cc
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x41fd
cmpb $0x0, 0x1(%rdi)
je 0x53c3
movl (%rdi), %ebp
callq 0x22c0
movq 0x12c04(%rip), %rcx     # 0x17fb0
movq (%rbx), %rdx
leaq -0xdea(%rip), %rsi      # 0x45cc
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4220
callq 0x22c0
movq (%rbx), %rdi
leaq -0x908(%rip), %rsi      # 0x4aca
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x41ab