LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/utilities.c
// Function: countWords
int countWords(char *query){
    int counter = 0, queryLength = strlen(query), i = 0;

    if (!strcmp(query, ""))
        return 0;

    while (i++ <= queryLength && counter < 10){
        if (*query == ' ' || *query == '\t' || *query == '\0')
            counter++;      // increase the number of words
        query++;            // go to next character
    }
    return counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
cmpb $0x0, (%rbx)
je 0x2cd3
movq %rax, %rcx
xorl %edx, %edx
movabsq $0x100000201, %rsi      # imm = 0x100000201
xorl %eax, %eax
cmpl %ecx, %edx
jg 0x2cd5
cmpl $0x9, %eax
jg 0x2cd5
movzbl (%rbx,%rdx), %edi
cmpq $0x20, %rdi
ja 0x2cce
btq %rdi, %rsi
jae 0x2cce
incl %eax
incq %rdx
jmp 0x2cb3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: place
void place(pool_t *pool, char *url) {

    pthread_mutex_lock(&mtx);

    while (pool->count >= POOL_SIZE){
        pthread_cond_wait(&cond_nonfull, &mtx);
    }
    pool->end = (pool->end + 1) % POOL_SIZE;

    strcpy(pool->url[pool->end], url);
    pool->count++;

    pthread_mutex_unlock(&mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x485a(%rip), %r15      # 0x7598
movq %r15, %rdi
callq 0x23b0
leaq 0x48cb(%rip), %r12      # 0x7618
cmpl $0x32, 0x1390(%rbx)
jl 0x2d63
movq %r12, %rdi
movq %r15, %rsi
callq 0x20a0
jmp 0x2d4d
movl 0x138c(%rbx), %eax
incl %eax
pushq $0x32
popq %rcx
cltd
idivl %ecx
movl %edx, 0x138c(%rbx)
movslq %edx, %rax
imulq $0x64, %rax, %rdi
addq %rbx, %rdi
movq %r14, %rsi
callq 0x2050
incl 0x1390(%rbx)
leaq 0x4802(%rip), %rdi      # 0x7598
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2230
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: obtain
char  *obtain(pool_t *pool) {
    char *url;

    pthread_mutex_lock(&mtx);

    while (pool->count <= 0){
        ready++;
        pthread_cond_wait(&cond_nonempty, &mtx);
    }
    url = pool->url[pool->end];

    pool->start = (pool->start + 1) % POOL_SIZE;
    pool->count--;
    pthread_mutex_unlock(&mtx);

    return url;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x47e1(%rip), %r14      # 0x7598
movq %r14, %rdi
callq 0x23b0
leaq 0x4822(%rip), %r15      # 0x75e8
movl 0x1390(%rbx), %ecx
testl %ecx, %ecx
jg 0x2de3
incl 0x487a(%rip)            # 0x7650
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
jmp 0x2dc6
movslq 0x138c(%rbx), %rax
imulq $0x64, %rax, %r14
addq %rbx, %r14
movl 0x1388(%rbx), %eax
incl %eax
pushq $0x32
popq %rsi
cltd
idivl %esi
movl %edx, 0x1388(%rbx)
decl %ecx
movl %ecx, 0x1390(%rbx)
leaq 0x4784(%rip), %rdi      # 0x7598
callq 0x2230
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: readSaveFolder
void readSaveFolder(char *path){
    DIR *dp;
    struct dirent *dir;
    char *newName;
    if((dp = opendir(path)) == NULL){                       // Open directory
        perror("save_dir opendir");
        return;
    }
    while((dir = readdir(dp)) != NULL){                     // Read contents till the end
        if(dir->d_ino == 0)                                 // Ignore removed entries
            continue;
        newName = malloc(strlen(path)+strlen(dir->d_name)+2);
        strcpy(newName, path);                              // Compose pathname

        if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..") ) { //Filter out
            //do nothing
        }
        else{
            strcat(newName, dir->d_name);
            strcat(newName, "/");
            insertDocfile(newName);
        }
        free(newName);
    }
    closedir(dp);                                           // Close directory
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20c0
testq %rax, %rax
je 0x33fa
movq %rax, %r14
movq %r14, %rdi
callq 0x2220
testq %rax, %rax
je 0x33e4
movq %rax, %r15
cmpq $0x0, (%rax)
je 0x334a
movq %rbx, %rdi
callq 0x20d0
movq %rax, %r12
movq %r15, %r13
addq $0x13, %r13
movq %r13, %rdi
callq 0x20d0
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2240
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
cmpb $0x2e, 0x13(%r15)
jne 0x33b5
cmpb $0x0, 0x14(%r15)
je 0x33d7
cmpb $0x2e, 0x14(%r15)
jne 0x33b5
cmpb $0x0, 0x15(%r15)
je 0x33d7
movq %r12, %rdi
movq %r13, %rsi
callq 0x2310
movq %r12, %rdi
callq 0x20d0
movw $0x2f, (%r12,%rax)
movq %r12, %rdi
callq 0x3b6f
movq %r12, %rdi
callq 0x2030
jmp 0x334a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2140
leaq 0x10ba(%rip), %rdi      # 0x44bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: prepareReq
int prepareReq(char *domain, int port, char *path, int sockfd){
    char request[500];

    sprintf(request, "GET %s HTTP/1.1\nUser-Agent: Mozilla/4.0 (compatible; MSIE5.01; Windows NT)\nHost: %s\nAccept-Language: en-us\nAccept-Encoding: gzip, deflate\nConnection: Keep-Alive\n\n", path, domain);
    customWrite(sockfd, request, strlen(request));

    return (int) strlen(request);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %ecx, %ebx
movq %rdi, %rcx
leaq 0xc50(%rip), %rsi       # 0x43ba
leaq -0x210(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2320
movq %r14, %rdi
callq 0x20d0
movl %ebx, %edi
movq %r14, %rsi
movl %eax, %edx
callq 0x34bb
movq %r14, %rdi
callq 0x20d0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: getHeaderSize
int getHeaderSize(char *header){
    char *size;
    int headerSize = 0, start, end;

    start = strlen(header);
    size = strstr(header, "<!DOCTYPE html>");
    end = strlen(size);

    headerSize = start - end;

    return headerSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r14
leaq 0xc66(%rip), %rsi       # 0x446e
movq %rbx, %rdi
callq 0x23a0
movq %rax, %rdi
callq 0x20d0
subl %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: createSaveFile
FILE *createSaveFile(char *path, char *save_dir){
    char folderName[200], saveDir[200], *folder, tempPath[200];
    FILE *file;
    struct stat st = {0};

    strcpy(saveDir, "./");
    strcat(saveDir, save_dir);
    strcat(saveDir, "/");

    if (stat(saveDir, &st) == -1) {
        if(mkdir(saveDir, 0700) == -1)                  // Create parent dir
            perror("parent mkdir");
    }
    strcpy(tempPath,path);
    folder = strtok(tempPath, "/");

    strcat(saveDir, folder);

    if (stat(saveDir, &st) == -1) {
        if(mkdir(saveDir, 0700) == -1)                  // Create siteX dir
            perror("subdir mkdir");
    }

    strcpy(folderName, save_dir);
    strcat(folderName, path);

    file = fopen(folderName, "w+");                     // Create desired file

    if(file == NULL){
        perror_exit("fopen");
    }

    return file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x180(%rbp), %r15
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2120
leaq -0xf0(%rbp), %r12
movw $0x2f2e, (%r12)         # imm = 0x2F2E
movb $0x0, 0x2(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x2310
movq %r12, %rdi
callq 0x20d0
movw $0x2f, -0xf0(%rbp,%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x21e0
cmpl $-0x1, %eax
jne 0x38c6
leaq -0xf0(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x2060
cmpl $-0x1, %eax
je 0x3964
leaq -0x250(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2050
leaq 0x982(%rip), %rsi       # 0x4261
movq %r15, %rdi
callq 0x22d0
leaq -0xf0(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2310
leaq -0x180(%rbp), %rsi
movq %r15, %rdi
callq 0x21e0
cmpl $-0x1, %eax
jne 0x3923
leaq -0xf0(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x2060
cmpl $-0x1, %eax
je 0x3975
leaq -0x320(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2050
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2310
leaq 0xb51(%rip), %rsi       # 0x4498
movq %r15, %rdi
callq 0x22b0
testq %rax, %rax
je 0x3983
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb13(%rip), %rdi       # 0x447e
callq 0x22c0
jmp 0x38c6
leaq 0xb0f(%rip), %rdi       # 0x448b
callq 0x22c0
jmp 0x3923
leaq 0xb11(%rip), %rdi       # 0x449b
callq 0x32cd
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: searchUrl
char *searchUrl(char *inputFile, pool_t *pool){
    char *ahref, *relativeUrl, *temp, *saveptr, *fullpath, *finalUrl = NULL;
    int exists = 0;

    temp = (char *) malloc(strlen(inputFile) + 1);

    while ((ahref = strstr(inputFile, "<a href="))) {
        strcpy(temp, ahref);
        relativeUrl = strtok_r(temp + 8, "\"", &saveptr);                                       // Thread safe strtok

        finalUrl = (char *) malloc(strlen(relativeUrl) + 1);
        fullpath = (char *) malloc(strlen("./save_dir") + strlen(relativeUrl) + 1);

        finalUrl = stringReplace(relativeUrl, finalUrl);

        strcpy(fullpath, "save_dir");
        strcat(fullpath, finalUrl);                                                             // Pass relative path to access

        if ((searchPool(pool, finalUrl) == 1) && ((!fileExist(fullpath)))) {   					// Url doesnt exist anywhere
            place(pool, finalUrl);
        }
        if(inputFile != NULL)
            inputFile = ahref + 8;                                                              // Move pointer after a href
    }
    free(temp);
    free(finalUrl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
callq 0x20d0
leaq 0x1(%rax), %rdi
callq 0x2240
movq %rax, -0x30(%rbp)
addq $0x8, %rax
movq %rax, -0x40(%rbp)
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0xad3(%rip), %rsi       # 0x44a1
callq 0x23a0
testq %rax, %rax
je 0x3a8a
movq %rax, %r15
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq -0x40(%rbp), %rdi
leaq 0xab4(%rip), %rsi       # 0x44aa
leaq -0x48(%rbp), %rdx
callq 0x2150
movq %rax, %rbx
movq %rax, %rdi
callq 0x20d0
movq %rax, %r12
leaq 0x1(%rax), %rdi
callq 0x2240
movq %rax, %r13
addq $0xb, %r12
movq %r12, %rdi
callq 0x2240
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3aaa
movabsq $0x7269645f65766173, %rax # imm = 0x7269645F65766173
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2310
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x3af6
testl %eax, %eax
je 0x3a7a
movq %r12, %rdi
callq 0x3b46
testl %eax, %eax
jne 0x3a7a
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x2d26
addq $0x8, %r15
testq %r14, %r14
cmovneq %r15, %r14
jmp 0x39c4
movq -0x30(%rbp), %rdi
callq 0x2030
movq %r13, %rdi
callq 0x2030
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: stringReplace
char *stringReplace(char *string, char *output){

    if((strstr(string, "..")) != NULL){                             // If the file is like "../siteX/"
        string += 2;
    }
    else if(strstr(string, "./") != NULL)                           // If the file is like "./siteY/"
        string++;

    strcpy(output, string);

    return output;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa4e(%rip), %rsi       # 0x450c
callq 0x23a0
testq %rax, %rax
je 0x3acd
pushq $0x2
popq %rcx
jmp 0x3ae4
leaq 0x78c(%rip), %rsi       # 0x4260
movq %r14, %rdi
callq 0x23a0
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
addq %rcx, %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: searchPool
int searchPool(pool_t *pool, char *url){
    int max, i;
    max = pool->count;
    for (i = 0; i <= max; i++) {
        if (!strcmp(url, pool->url[i]))                             // Url exists in pool
            return 0;
    }

    return 1;                                                       // Url doesnt exist
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rsi
movslq 0x1390(%rdi), %r15
pushq $-0x1
popq %r12
pushq $0x1
popq %rbx
incq %r12
cmpq %r15, %r12
jg 0x3b35
leaq 0x64(%rsi), %r13
movq %r14, %rdi
callq 0x2190
movq %r13, %rsi
testl %eax, %eax
jne 0x3b18
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/support.c
// Function: insertDocfile
void insertDocfile(char *path){
    FILE *file;

    file = fopen("docfile", "a");                          	// Create desired file

    if(file == NULL){
        perror_exit("fopen");
    }

    fprintf(file, "%s\n", path);

    fclose(file);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x72a(%rip), %rdi       # 0x42aa
leaq 0x92e(%rip), %rsi       # 0x44b5
callq 0x22b0
testq %rax, %rax
je 0x3bb4
movq %rax, %r14
leaq 0x91c(%rip), %rsi       # 0x44b7
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21c0
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20b0
leaq 0x8e0(%rip), %rdi       # 0x449b
callq 0x32cd
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/jobexec.c
// Function: cleanUp
void cleanUp(int numWorkers, DocumentNode *documentArray, int nDocs) {
    int i;
    char pipeOut[50], pipeIn[50];

    for (i = 0; i < numWorkers; i++) {
        sprintf(pipeIn, "/tmp/fifo_%d_in", i);
        sprintf(pipeOut, "/tmp/fifo_%d_out", i);

        close(fdIn[i]);
        close(fdOut[i]);

        unlink(pipeIn);
        unlink(pipeOut);
    }

    destroyDocuments(documentArray, nDocs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, -0x2c(%rbp)
movl %edi, %r14d
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %r14d
movq %rsi, -0x38(%rbp)
leaq -0x70(%rbp), %r13
leaq -0xb0(%rbp), %r15
leaq 0x37bf(%rip), %rbx      # 0x7668
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x3f0d
movq %r13, %rdi
leaq 0x6fb(%rip), %rsi       # 0x45b6
movl %r12d, %edx
xorl %eax, %eax
callq 0x2320
movq %r15, %rdi
leaq 0x6f7(%rip), %rsi       # 0x45c6
movl %r12d, %edx
xorl %eax, %eax
callq 0x2320
leaq 0x3780(%rip), %rax      # 0x7660
movq (%rax), %rax
movl (%rax,%r12,4), %edi
callq 0x2130
movq (%rbx), %rax
movl (%rax,%r12,4), %edi
callq 0x2130
movq %r13, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2040
incq %r12
jmp 0x3eac
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2853
// File: /workspace/github_c_makefile_star2_O2/adelciotto[P]scg/examples/basic.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Basic";

    scg_app_t app;
    scg_app_init(&app, config);

    while (scg_app_process_events(&app)) {
        draw(app.draw_target);

        scg_app_present(&app);
    }

    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movabsq $0x1e000000280, %rax    # imm = 0x1E000000280
movq %rax, 0x38(%rsp)
movl $0x1, 0x48(%rsp)
xorl %eax, %eax
movb %al, 0x4c(%rsp)
movl $0x1010101, 0x4d(%rsp)  # imm = 0x1010101
movb %al, 0x54(%rsp)
movl $0x40, 0x58(%rsp)
leaq 0x1499(%rip), %rax      # 0x65ac
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x3dc3
movq %rbx, %rdi
callq 0x4858
testb %al, %al
je 0x524d
movq 0x98(%rsp), %r12
movl (%r12), %ecx
movl 0x4(%r12), %eax
cvtsi2ss %ecx, %xmm0
movss 0xe99(%rip), %xmm2      # 0x6008
movaps %xmm2, %xmm3
cvtsi2ss %eax, %xmm1
divss %xmm0, %xmm3
movss %xmm3, 0x34(%rsp)
divss %xmm1, %xmm2
movss %xmm2, 0x30(%rsp)
xorl %ebp, %ebp
testl %ecx, %ecx
movl $0x0, %ebx
movl %ecx, 0x28(%rsp)
cmovgl %ecx, %ebx
testl %eax, %eax
movl $0x0, %r13d
movl %eax, 0x2c(%rsp)
cmovgl %eax, %r13d
cmpl %r13d, %ebp
je 0x520d
cvtsi2ss %ebp, %xmm0
mulss 0x30(%rsp), %xmm0
mulss 0xe4b(%rip), %xmm0      # 0x600c
cvttss2si %xmm0, %eax
shll $0x8, %eax
movzwl %ax, %r14d
xorl %r15d, %r15d
cmpl %r15d, %ebx
je 0x5209
cvtsi2ss %r15d, %xmm0
mulss 0x34(%rsp), %xmm0
mulss 0xe25(%rip), %xmm0      # 0x600c
cvttss2si %xmm0, %ecx
shll $0x10, %ecx
orl %r14d, %ecx
orl $0xff000080, %ecx       # imm = 0xFF000080
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2b4d
incl %r15d
jmp 0x51cf
incl %ebp
jmp 0x51aa
movl 0x28(%rsp), %eax
cltd
pushq $0x2
popq %rsi
idivl %esi
movl %eax, %ecx
movl 0x2c(%rsp), %eax
cltd
idivl %esi
movq %r12, %rdi
leaq 0x1f88(%rip), %rsi      # 0x71b2
movl %ecx, %edx
movl %eax, %ecx
pushq $0x1
popq %r8
pushq $-0x1
popq %r9
callq 0x38fd
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x491f
jmp 0x5142
leaq 0x60(%rsp), %rdi
callq 0x4bf7
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hsvm/src/assembler.c
// Function: match_rule
int match_rule (struct _token * tokens)
{
    struct _token * next;
    int i, j;

    for (i = 0; rule_matrix[i][0] != ASSEM_TERM; i++) {
        j = 0;
        next = tokens;
        while (1) {
            if (rule_matrix[i][j] == ASSEM_TERM)
                return i;
            if (next == NULL)
                break;
            if (rule_matrix[i][j] != token_to_assem(next))
                break;
            next = next->next;
            j++;
        }
    }
    return -1;
}

// Assembly:
pushq %rbx
leaq 0x6d8e(%rip), %rdx      # 0x9180
xorl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x80, %esi
movq %rdx, %r8
cmpb $-0x71, (%rdx,%rcx,8)
je 0x243d
movq %r8, %r9
movq %rdi, %r10
movb (%r9), %r11b
cmpb $-0x71, %r11b
je 0x243b
testq %r10, %r10
je 0x2432
movl (%r10), %ebx
cmpl $0xb, %ebx
cmovbl %esi, %ebx
cmpb %bl, %r11b
jne 0x2432
movq 0x10(%r10), %r10
incq %r9
jmp 0x240d
incq %rcx
addq $0x8, %r8
jmp 0x2401
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hsvm/src/assembler.c
// Function: advance_token
struct _token * advance_token (struct _token * token, int steps)
{
    int i;
    for (i = 0; i < steps; i++) {
        token = token->next;
    }
    return token;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
subl $0x1, %ecx
jb 0x2471
movq 0x10(%rax), %rax
jmp 0x2466
retq
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hsvm/src/assembler.c
// Function: token_peek
struct _token * token_peek (struct _token * token, int depth)
{
    int i;
    for (i = 0; i < depth; i++) {
        token = token->next;
    }
    return token;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
subl $0x1, %ecx
jb 0x2487
movq 0x10(%rax), %rax
jmp 0x247c
retq
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hsvm/src/assembler.c
// Function: label_create
struct _label * label_create (const char * str, uint16_t location)
{
    struct _label * label;

    label = (struct _label *) malloc(sizeof(struct _label));
    label->str = (char *) malloc(strlen(str) + 1);
    strcpy(label->str, str);
    label->location = location;
    label->next = NULL;

    return label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x21f0
movq %rax, %r15
movq %r14, %rdi
callq 0x2100
leaq 0x1(%rax), %rdi
callq 0x21f0
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
movw %bx, 0x8(%r15)
andq $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hsvm/src/assembler.c
// Function: labels_append
void labels_append (struct _labels * labels, struct _label * label)
{
    if (labels->first == NULL) {
        labels->first = label;
        labels->last  = label;
    }
    else {
        labels->last->next = label;
        labels->last = label;
    }
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x24e3
movq 0x8(%rdi), %rax
addq $0x8, %rdi
movq %rsi, 0x10(%rax)
jmp 0x24ea
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hsvm/src/assembler.c
// Function: get_tokens
struct _token * get_tokens (const char * filename)
{
    FILE * fh;
    size_t filesize;
    char * buf;

    fh = fopen(filename, "r");
    if (fh == NULL) {
        fprintf(stderr, "could not open file %s\n", filename);
        return NULL;
    }

    fseek(fh, 0, SEEK_END);
    filesize = ftell(fh);
    fseek(fh, 0, SEEK_SET);

    buf = (char *) malloc(filesize + 1);

    fread(buf, 1, filesize, fh);
    buf[filesize] = '\0';

    fclose(fh);

    struct _token * tokens = lexer(buf);

    if (tokens == NULL)
        printf("lexer error in file: %s\n", filename);

    free(buf);

    return tokens;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b46(%rip), %rsi      # 0x6653
callq 0x2270
testq %rax, %rax
je 0x2ba5
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2210
movq %r14, %rdi
callq 0x21d0
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2210
leaq 0x1(%r12), %rdi
callq 0x21f0
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x20d0
movb $0x0, (%r15,%r12)
movq %r14, %rdi
callq 0x20f0
movq %r15, %rdi
callq 0x312f
movq %rax, %r14
testq %rax, %rax
jne 0x2b8e
leaq 0x36e8(%rip), %rdi      # 0x626c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2120
movq %r15, %rdi
callq 0x2040
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x644c(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x369e(%rip), %rsi      # 0x6254
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21c0
jmp 0x2b96
// File: /workspace/github_c_makefile_star2_O2/endeav0r[P]hsvm/src/assembler.c
// Function: write_mem
int write_mem (const char * filename, unsigned char * mem, int mem_size)
{
    FILE * fh;

    fh = fopen(filename, "wb");
    if (fh == NULL) {
        fprintf(stderr, "could not open file %s\n", filename);
        return -1;
    }

    fwrite(mem, 1, mem_size, fh);

    fclose(fh);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x36aa(%rip), %rsi      # 0x6285
callq 0x2270
testq %rax, %rax
je 0x2c0e
movq %rax, %r15
movslq %ebp, %rdx
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0x22c0
movq %r15, %rdi
callq 0x20f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x63e3(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x3635(%rip), %rsi      # 0x6254
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21c0
pushq $-0x1
popq %rax
jmp 0x2c03
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1hanuman120/ref/primate.cpp
// Function: MixColumns(unsigned char*)
void MixColumns(unsigned char *state) //MixColumns operation on the state
{
	unsigned char tmp[StateSize];
	for(int p=0; p<NumberRows; p++){
		for(int i=0; i<NumberColumns; i++){
			for(int j=0; j<(NumberRows-1); j++)
				tmp[NumberColumns*j+i]=state[NumberColumns*(j+1)+i];
			tmp[NumberColumns*6+i]=state[i]^T2(state[NumberColumns*1+i])^T15(state[NumberColumns*2+i])^T9(state[NumberColumns*3+i])^T9(state[NumberColumns*4+i])^T15(state[NumberColumns*5+i])^T2(state[NumberColumns*6+i]);
		}
		for(int j=0; j<StateSize; j++)
			state[j]=tmp[j];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x7, %eax
je 0x1f2d
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %r12
leaq 0x20(%rsp), %r13
xorl %r14d, %r14d
xorl %eax, %eax
cmpq $0x8, %r14
jne 0x1e78
jmp 0x1f1b
movb (%r12,%rax,8), %cl
movb %cl, (%r13,%rax,8)
incq %rax
cmpq $0x6, %rax
jne 0x1e6c
movb 0x8(%r15,%r14), %bl
leal (%rbx,%rbx), %eax
andb $0x1e, %al
shlb $0x3, %bl
sarb $0x7, %bl
andb $0x5, %bl
movzbl 0x10(%r15,%r14), %edi
xorb (%r15,%r14), %al
movl %eax, 0xc(%rsp)
callq 0x1150
movl %eax, %ebp
movzbl 0x18(%r15,%r14), %edi
callq 0x1180
movb %al, 0xb(%rsp)
movzbl 0x20(%r15,%r14), %edi
callq 0x1180
movb %al, 0xa(%rsp)
movzbl 0x28(%r15,%r14), %edi
callq 0x1150
movb 0x30(%r15,%r14), %cl
leal (%rcx,%rcx), %edx
andb $0x1e, %dl
shlb $0x3, %cl
sarb $0x7, %cl
andb $0x5, %cl
xorb %dl, %cl
xorb %bl, %bpl
xorb 0xb(%rsp), %bpl
xorb 0xa(%rsp), %bpl
xorb %al, %bpl
xorb 0xc(%rsp), %bpl
xorb %cl, %bpl
movb %bpl, 0x50(%rsp,%r14)
incq %r14
incq %r13
incq %r12
jmp 0x1e5f
movb 0x20(%rsp,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
cmpq $0x38, %rax
jne 0x1f10
movq 0x18(%rsp), %rax
incl %eax
jmp 0x1e44
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/windowedblockmodel.h
// Function: findBestBitsPerKeyPerBlockWindow
size_t findBestBitsPerKeyPerBlockWindow(size_t HowManyKeys, size_t bitbudget,
                                  size_t BlockSizeInBits, size_t WindowSizeInBits,
                                  sim_stats_t *beststats, bool verbose) {
  windowed_model_t m;
  m.TotalBits = bitbudget;
  m.BlockSizeInBits = BlockSizeInBits;
  m.WindowSizeInBits = WindowSizeInBits;
  size_t howmanytests = 50000;
  bitset_t *b = bitset_create_with_capacity(bitbudget);
  beststats->collision_rate = 1.0;
  size_t BestBitsPerKeyPerBlock = 0;
  for (size_t BitsPerKeyPerBlock = 1;
       (BitsPerKeyPerBlock <= 16) ||
       (BestBitsPerKeyPerBlock == BitsPerKeyPerBlock);
       BitsPerKeyPerBlock++) {
    m.BitsPerKeyPerBlock = BitsPerKeyPerBlock;
    // we take the average of several attempts
    //double collisionrate = 0;
    sim_stats_t s;
    s.collision_rate = 0;
    s.density = 0;
    size_t attempts = HowManyKeys < 10000000 ? 5 : 1;
    for (int i = 0; i < attempts; i++) {
      sim_stats_t ts = simulateWindow(HowManyKeys, m, howmanytests, b);
      s.density += ts.density;
      s.collision_rate += ts.collision_rate;
    }
    s.collision_rate /= attempts;
    s.density /= attempts;

    if (s.collision_rate * 1.01 <
        beststats->collision_rate) { // has to be at least one percent better
      beststats->collision_rate = s.collision_rate;
      beststats->density = s.density; 
      BestBitsPerKeyPerBlock = BitsPerKeyPerBlock;
    }
  }
  bitset_free(b);
  return BestBitsPerKeyPerBlock;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rdi, %r14
movq %rsi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x60(%rsp)
movq %rsi, %rdi
callq 0x1c1b
movq %rax, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
xorl %ecx, %ecx
cmpq $0x989680, %r14         # imm = 0x989680
setb %cl
leaq 0x1(,%rcx,4), %rcx
movq %rcx, 0x38(%rsp)
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x30(%rsp)
movq %rax, (%rbx)
pushq $0x1
popq %rbp
xorl %r12d, %r12d
cmpq $0x11, %rbp
setb %al
cmpq %rbp, %r12
sete %cl
orb %al, %cl
je 0x15f4
movq %rbp, 0x48(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %r13
xorpd %xmm2, %xmm2
subq $0x1, %r13
jb 0x15b8
movupd 0x48(%rsp), %xmm0
movupd 0x58(%rsp), %xmm1
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movl $0xc350, %esi           # imm = 0xC350
movq %r14, %rdi
movq %r15, %rdx
movsd %xmm2, 0x40(%rsp)
callq 0x1254
movsd 0x28(%rsp), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x28(%rsp)
movsd 0x40(%rsp), %xmm2
addsd %xmm0, %xmm2
jmp 0x1569
divsd 0x30(%rsp), %xmm2
movapd %xmm2, %xmm0
mulsd 0x1aa6(%rip), %xmm0     # 0x3070
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x15ec
movsd 0x28(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
movsd %xmm2, (%rbx)
movsd %xmm0, 0x8(%rbx)
movq %rbp, %r12
incq %rbp
jmp 0x153c
movq %r15, %rdi
callq 0x1ef5
movq %r12, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/windowedblockmodel.h
// Function: assessWindowedBlockSize
void assessWindowedBlockSize(size_t HowManyKeys, size_t BlockSizeInBits, size_t WindowSizeInBits, bool verbose) {
  for (size_t bitsperkey = 8; bitsperkey <= 16; bitsperkey += 4) {
    size_t bitbudget = bitsperkey * HowManyKeys;
    sim_stats_t beststats;
    size_t bestbitsperbucket = findBestBitsPerKeyPerBlockWindow(
        HowManyKeys, bitbudget, BlockSizeInBits, WindowSizeInBits, &beststats, verbose);
    double density = bestbitsperbucket * 1.0 / bitsperkey;

    double theoretical_best_bits = log(1.0/beststats.collision_rate) / log(2.0);
    double inefficiency = (bitsperkey/theoretical_best_bits - 1.0) * 100.0;
    

    printf("bits per key %3zu WindowSizeInBits %3zu best bits per bucket = %zu, max density = %0.0f %%, density = %0.0f %%, collision rate = "
           "%0.3f %%, inefficiency = %0.1f %% \n",
           bitsperkey, WindowSizeInBits, bestbitsperbucket, density * 100,   beststats.density * 100, beststats.collision_rate * 100, inefficiency);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
leaq (,%rdi,8), %r12
leaq (,%rdi,4), %r14
pushq $0x8
popq %r13
cmpq $0x11, %r13
jae 0x171d
movq %r15, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
leaq 0x20(%rsp), %r8
xorl %r9d, %r9d
callq 0x14d8
movq %rax, %rbp
movq %rax, %xmm0
punpckldq 0x19e0(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x19e8(%rip), %xmm0     # 0x3060
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvtsi2sd %r13, %xmm0
movsd %xmm0, 0x10(%rsp)
divsd %xmm0, %xmm1
movapd %xmm1, 0x30(%rsp)
movsd 0x20(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x19cb(%rip), %xmm0     # 0x3078
divsd %xmm1, %xmm0
callq 0x1090
divsd 0x19c2(%rip), %xmm0     # 0x3080
movsd 0x10(%rsp), %xmm3
divsd %xmm0, %xmm3
addsd 0x19b8(%rip), %xmm3     # 0x3088
movsd 0x19b8(%rip), %xmm4     # 0x3090
mulsd %xmm4, %xmm3
movapd 0x30(%rsp), %xmm0
mulsd %xmm4, %xmm0
movsd 0x28(%rsp), %xmm1
mulsd %xmm4, %xmm1
movsd 0x18(%rsp), %xmm2
mulsd %xmm4, %xmm2
leaq 0x1997(%rip), %rdi      # 0x3098
movq %r13, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movb $0x4, %al
callq 0x1070
addq $0x4, %r13
addq %r14, %r12
jmp 0x163b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/windowedblockmodel.c
// Function: compute
void compute(size_t HowManyKeys) {
  bool verbose = false;
  printf("Number of keys %zu \n", HowManyKeys);
  printf(" cache line (512-bits) \n");
  assessBlockSize(HowManyKeys, 512, verbose);

  for(size_t window = 8; window <= 512; window*=2) {
    assessWindowedBlockSize(HowManyKeys, 512, window, verbose);
  }
  printf("\n");

  printf("quarter cache line (128-bits) \n");
  assessBlockSize(HowManyKeys, 128, verbose);

  for(size_t window = 8; window <= 128; window*=2) {
    assessWindowedBlockSize(HowManyKeys, 128, window, verbose);
  }  

  printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x16ae(%rip), %rdi      # 0x31cc
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x16b2(%rip), %rdi      # 0x31e1
callq 0x1060
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a01
pushq $0x8
popq %r14
cmpq $0x201, %r14            # imm = 0x201
jae 0x1b67
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x160e
addq %r14, %r14
jmp 0x1b47
pushq $0xa
popq %rdi
callq 0x1040
leaq 0x1683(%rip), %rdi      # 0x31f9
callq 0x1060
movl $0x80, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a01
pushq $0x8
popq %r14
cmpq $0x81, %r14
jae 0x1bae
movl $0x80, %esi
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x160e
addq %r14, %r14
jmp 0x1b8e
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_expr.c
// Function: main
int main(int argc, char **argv) {
    if (argc > 1) {
        hts_expr_val_t v = HTS_EXPR_VAL_INIT;
        hts_filter_t *filt = hts_filter_init(argv[1]);
        if (hts_filter_eval2(filt, NULL, lookup, &v))
            return 1;

        printf("%s\t", v.is_true ? "true":"false");

        if (v.is_str)
            puts(v.s.s);
        else
            printf("%g\n", v.d);

        hts_expr_val_free(&v);
        hts_filter_free(filt);
        return 0;
    }

    return test();
}

// Assembly:
cmpl $0x2, %edi
jl 0x5d55
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
andq $0x0, 0x20(%r14)
movq 0x8(%rsi), %rdi
callq 0x7944
movq %rax, %rbx
leaq -0x1e0c(%rip), %rdx     # 0x5abc
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x7ad1
testl %eax, %eax
je 0x78de
pushq $0x1
popq %rax
jmp 0x793b
cmpb $0x0, 0x1(%rsp)
leaq 0x6bdb5(%rip), %rax     # 0x7369f
leaq 0x6b939(%rip), %rsi     # 0x7322a
cmoveq %rax, %rsi
leaq 0x6bdf9(%rip), %rdi     # 0x736f5
xorl %eax, %eax
callq 0x4060
cmpb $0x0, (%rsp)
je 0x7915
movq 0x18(%rsp), %rdi
callq 0x47d0
jmp 0x7929
movsd 0x20(%rsp), %xmm0
leaq 0x6bdd7(%rip), %rdi     # 0x736f9
movb $0x1, %al
callq 0x4060
movq %rsp, %rdi
callq 0x7876
movq %rbx, %rdi
callq 0x799b
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/9-File/endian.c
// Function: main
int main(void) 	{
	unsigned long temp = 0x89ABCDEF;
	int i;
	unsigned char *ptr = (unsigned char *) &temp;

	if(ptr[0] == 0xef) {
		printf("This CPU is little endian, i.e., ending value in small (little) address\n");
	}
	else {
		printf("This CPU is big endian, i.e., ending value in big address\n");
	}

	printf("Byte-by-byte printing:\t");
	for(i = 0; i < sizeof(unsigned long); i++)
		printf("%x", ptr[i]);
	printf("\n");

	printf("Printing by value:\t");
	printf("%lx\n", temp);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x89abcdef, %eax       # imm = 0x89ABCDEF
movq %rax, (%rsp)
leaq 0xec8(%rip), %rdi       # 0x2038
callq 0x1040
leaq 0xe88(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1050
leaq 0xe92(%rip), %rbx       # 0x201c
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x11a7
movzbl (%rsp,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1050
incq %r14
jmp 0x118d
pushq $0xa
popq %rdi
callq 0x1030
leaq 0xe69(%rip), %rdi       # 0x201f
xorl %eax, %eax
callq 0x1050
leaq 0xe6f(%rip), %rdi       # 0x2033
movl $0x89abcdef, %esi       # imm = 0x89ABCDEF
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoomanist[P]carrot/cd.c
// Function: main
int main(int argc, char **argv)
{
	if(argc == 1)
	{
		chdir("~");
		return 0;
	}
	else if(argc > 2)
	{
		puts("this is simplest implemention");
		return 0;
	}
	chdir(argv[1]);


}

// Assembly:
pushq %rax
cmpl $0x1, %edi
jne 0x115b
leaq 0xeab(%rip), %rdi       # 0x2004
jmp 0x1172
cmpl $0x3, %edi
jl 0x116e
leaq 0xe9f(%rip), %rdi       # 0x2006
callq 0x1030
jmp 0x1177
movq 0x8(%rsi), %rdi
callq 0x1040
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hoomanist[P]carrot/cat.c
// Function: show
void show(char path[PATH_MAX])
{
	int c;
	FILE *fp;
	fp = fopen(path, "r");
	if(fp == NULL) {
      		perror("Error in opening file");
   	} do {
      		c = fgetc(fp);
      		if( feof(fp) ) {
         		break ;
      		}
      		printf("%c", c);
   	} while(1);
	fclose(fp);

}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xe5e(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, %rbx
testq %rax, %rax
jne 0x11c8
leaq 0xe4c(%rip), %rdi       # 0x2006
callq 0x1090
jmp 0x11c8
movl %ebp, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x1060
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
je 0x11c1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/hoomanist[P]carrot/cat.c
// Function: main
int main(int argc, char **argv)
{
	if(argc == 1)
	{
		printf("what the f#@& :/");
		return 0;
	}
	else if(argc > 2){
		printf("remember the simplicity");
		return 0;
	}

	show(argv[1]);	
	return 0;
}

// Assembly:
pushq %rax
cmpl $0x1, %edi
jne 0x11fb
leaq 0xe23(%rip), %rdi       # 0x201c
jmp 0x1207
cmpl $0x3, %edi
jl 0x1210
leaq 0xe26(%rip), %rdi       # 0x202d
xorl %eax, %eax
callq 0x1050
jmp 0x1219
movq 0x8(%rsi), %rdi
callq 0x119c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/lesgourg[P]class_public/build/../source/background.c
// Function: background_free_input
int background_free_input(
                          struct background *pba
                          ) {

  int k;

  if (pba->Omega0_ncdm_tot != 0.) {
    for (k=0; k<pba->N_ncdm; k++) {
      free(pba->q_ncdm[k]);
      free(pba->w_ncdm[k]);
      free(pba->q_ncdm_bg[k]);
      free(pba->w_ncdm_bg[k]);
      free(pba->dlnf0_dlnq_ncdm[k]);
    }
    free(pba->ncdm_quadrature_strategy);
    free(pba->ncdm_input_q_size);
    free(pba->ncdm_qmax);
    free(pba->q_ncdm);
    free(pba->w_ncdm);
    free(pba->q_ncdm_bg);
    free(pba->w_ncdm_bg);
    free(pba->dlnf0_dlnq_ncdm);
    free(pba->q_size_ncdm);
    free(pba->q_size_ncdm_bg);
    free(pba->M_ncdm);
    free(pba->T_ncdm);
    free(pba->ksi_ncdm);
    free(pba->deg_ncdm);
    free(pba->Omega0_ncdm);
    free(pba->m_ncdm_in_eV);
    free(pba->factor_ncdm);
    if (pba->got_files!=NULL)
      free(pba->got_files);
    if (pba->ncdm_psd_files!=NULL)
      free(pba->ncdm_psd_files);
    if (pba->ncdm_psd_parameters!=NULL)
      free(pba->ncdm_psd_parameters);
  }

  if (pba->Omega0_scf != 0.) {
    if (pba->scf_parameters != NULL)
      free(pba->scf_parameters);
  }
  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0xa8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5493a
jnp 0x54a8c
xorl %r14d, %r14d
movslq 0x70(%rbx), %rax
cmpq %rax, %r14
jge 0x5499b
movq 0x350(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x358(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x340(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x348(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
movq 0x360(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8430
incq %r14
jmp 0x5493d
movq 0x338(%rbx), %rdi
callq 0x8430
movq 0xe0(%rbx), %rdi
callq 0x8430
movq 0xe8(%rbx), %rdi
callq 0x8430
movq 0x350(%rbx), %rdi
callq 0x8430
movq 0x358(%rbx), %rdi
callq 0x8430
movq 0x340(%rbx), %rdi
callq 0x8430
movq 0x348(%rbx), %rdi
callq 0x8430
movq 0x360(%rbx), %rdi
callq 0x8430
movq 0x370(%rbx), %rdi
callq 0x8430
movq 0x368(%rbx), %rdi
callq 0x8430
movq 0x90(%rbx), %rdi
callq 0x8430
movq 0xb0(%rbx), %rdi
callq 0x8430
movq 0xc0(%rbx), %rdi
callq 0x8430
movq 0xd0(%rbx), %rdi
callq 0x8430
movq 0xa0(%rbx), %rdi
callq 0x8430
movq 0x98(%rbx), %rdi
callq 0x8430
movq 0x378(%rbx), %rdi
callq 0x8430
movq 0x80(%rbx), %rdi
callq 0x8430
movq 0x78(%rbx), %rdi
callq 0x8430
movq 0x88(%rbx), %rdi
callq 0x8430
xorpd %xmm1, %xmm1
movsd 0x108(%rbx), %xmm0
ucomisd %xmm1, %xmm0
jne 0x54a9c
jnp 0x54aa8
movq 0x148(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lesgourg[P]class_public/build/../source/primordial.c
// Function: primordial_analytic_spectrum
int primordial_analytic_spectrum(
                                 struct primordial * ppm,
                                 int index_md,
                                 int index_ic1_ic2,
                                 double k,
                                 double * pk
                                 ) {

  if (ppm->is_non_zero[index_md][index_ic1_ic2] == _TRUE_) {
    *pk = ppm->amplitude[index_md][index_ic1_ic2]
      *exp((ppm->tilt[index_md][index_ic1_ic2]-1.)*log(k/ppm->k_pivot)
           + 0.5 * ppm->running[index_md][index_ic1_ic2] * pow(log(k/ppm->k_pivot), 2.));

  }
  else {
    *pk = 0.;
  }

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movapd %xmm0, %xmm1
movq 0x2b0(%rdi), %rax
movslq %esi, %r15
movq (%rax,%r15,8), %rax
movslq %edx, %r12
xorpd %xmm0, %xmm0
cmpw $0x1, (%rax,%r12,2)
jne 0x8071d
movq %rdi, %r14
movq 0x2b8(%rdi), %rax
movq 0x2c0(%rdi), %rcx
movq (%rax,%r15,8), %rax
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,8), %xmm0
addsd 0x56148(%rip), %xmm0    # 0xd67e8
movsd %xmm0, 0x18(%rsp)
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm1, %xmm0
divsd (%rdi), %xmm0
movsd %xmm1, (%rsp)
callq 0x82e0
movsd %xmm0, 0x10(%rsp)
movq 0x2c8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
mulsd 0x565cd(%rip), %xmm0    # 0xd6cb0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
divsd (%r14), %xmm0
callq 0x82e0
mulsd %xmm0, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm1, %xmm0
callq 0x86a0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lesgourg[P]class_public/build/../source/lensing.c
// Function: lensing_free
int lensing_free(
                 struct lensing * ple
                 ) {

  if (ple->has_lensed_cls == _TRUE_) {

    free(ple->l);
    free(ple->cl_lens);
    free(ple->ddcl_lens);
    free(ple->l_max_lt);

  }

  ple->is_allocated = _FALSE_;

  return _SUCCESS_;

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpw $0x1, (%rdi)
jne 0xa9b0f
movq 0x70(%rbx), %rdi
callq 0x8430
movq 0x78(%rbx), %rdi
callq 0x8430
movq 0x80(%rbx), %rdi
callq 0x8430
movq 0x68(%rbx), %rdi
callq 0x8430
andw $0x0, 0x88a(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/X1319RAY[P]fileIO/fscanf.c
// Function: main
int main(int argc, char* argv[]){
	
	// コマンドライン引数のチェック
	if(argc != 2){
		fprintf(stderr, "引数の数が間違っています．\n");
		fprintf(stderr, "./fgets input.txt\n");
		return 1;
	}
	
	// C言語のファイル入力のための準備
	FILE* fp; // FILE型構造体
	// 読み込みモードでファイルを開く
	fp = fopen(argv[1], "r"); // 失敗するとNULLを返す
	// ファイルを開くのに失敗したときの処理
	if(fp == NULL){
		fprintf(stderr, "Error: file not opened.\n");
		return 1;
	}
	
	// fscanf()で書式指定で1行ずつ読み込む
	char tmp[BUFSIZE];
	int num;
	int sum = 0;
	while(fscanf(fp, "%s %d", tmp, &num) != EOF){
		// ここでtmpを煮るなり焼くなりする
		printf("%s %d\n", tmp, num); // そのまま出力
		// 値をsumに加算
		sum += num;
	}
	
	printf("\nsum: %d\n", sum);
	
	// ファイルを閉じる
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
cmpl $0x2, %edi
jne 0x122d
movq 0x8(%rsi), %rdi
leaq 0xe9c(%rip), %rsi       # 0x2040
callq 0x1060
testq %rax, %rax
je 0x125e
movq %rax, %rbx
leaq -0x430(%rbp), %r12
leaq -0x2c(%rbp), %r13
leaq 0xe9a(%rip), %r15       # 0x2061
xorl %r14d, %r14d
movq %rbx, %rdi
leaq 0xe87(%rip), %rsi       # 0x205b
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1030
cmpl $-0x1, %eax
je 0x11fc
movl -0x2c(%rbp), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1050
addl -0x2c(%rbp), %r14d
jmp 0x11ca
leaq 0xe65(%rip), %rdi       # 0x2068
xorl %r15d, %r15d
movl %r14d, %esi
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
callq 0x1040
movl %r15d, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2dc4(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0xdc6(%rip), %rdi       # 0x2004
pushq $0x28
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1070
movq (%r14), %rcx
leaq 0xdd7(%rip), %rdi       # 0x202d
pushq $0x12
popq %rsi
movq %rbx, %rdx
jmp 0x1275
movq 0x2d93(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdd3(%rip), %rdi       # 0x2042
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x1070
pushq $0x1
popq %r15
jmp 0x1218
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1ape120/ref/primate.cpp
// Function: MixColumnsInv(unsigned char*)
void MixColumnsInv(unsigned char *state) //Inverse MixColumns operation on the state
{
	unsigned char tmp[StateSize];
	for(int p=0; p<NumberRows; p++){
		for(int i=0; i<NumberColumns; i++){
			tmp[i]=T2(state[i])^T15(state[NumberColumns*1+i])^T9(state[NumberColumns*2+i])^T9(state[NumberColumns*3+i])^T15(state[NumberColumns*4+i])^T2(state[NumberColumns*5+i])^state[NumberColumns*6+i];
 			for(int j=1; j<NumberRows; j++)
				tmp[NumberColumns*j+i]=state[NumberColumns*(j-1)+i];
		}
		for(int j=0; j<StateSize; j++)
			state[j]=tmp[j];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
xorl %eax, %eax
cmpl $0x7, %eax
je 0x338a
movq %rax, 0x8(%rsp)
movq %r15, %rbx
leaq 0x18(%rsp), %r12
xorl %ebp, %ebp
cmpq $0x8, %rbp
je 0x3369
movb (%r15,%rbp), %r13b
leal (,%r13,2), %eax
andb $0x1e, %al
movl %eax, 0x4(%rsp)
shlb $0x3, %r13b
sarb $0x7, %r13b
andb $0x5, %r13b
movzbl 0x8(%r15,%rbp), %edi
callq 0x2170
movb %al, 0x3(%rsp)
movzbl 0x10(%r15,%rbp), %edi
callq 0x21b0
movb %al, 0x2(%rsp)
movzbl 0x18(%r15,%rbp), %edi
callq 0x21b0
movl %eax, %r14d
movzbl 0x20(%r15,%rbp), %edi
callq 0x2170
movb 0x28(%r15,%rbp), %cl
leal (%rcx,%rcx), %edx
andb $0x1e, %dl
shlb $0x3, %cl
sarb $0x7, %cl
andb $0x5, %cl
xorb %dl, %cl
movb 0x3(%rsp), %sil
xorb 0x4(%rsp), %sil
xorb %r13b, %sil
xorb 0x2(%rsp), %r14b
xorb %al, %r14b
xorb %sil, %r14b
xorb 0x30(%r15,%rbp), %r14b
xorb %cl, %r14b
movb %r14b, 0x10(%rsp,%rbp)
xorl %eax, %eax
cmpq $0x6, %rax
je 0x335b
movb (%rbx,%rax,8), %cl
movb %cl, (%r12,%rax,8)
incq %rax
jmp 0x3349
incq %rbp
incq %r12
incq %rbx
jmp 0x32ad
xorl %eax, %eax
cmpq $0x38, %rax
je 0x337e
movb 0x10(%rsp,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
jmp 0x336b
movq 0x8(%rsp), %rax
incl %eax
jmp 0x3295
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhoudian64[P]OS2-exp/receiver.c
// Function: main
int main() {
	char buf[20];
	close(0);
	open("./mypipe.txt", O_RDWR);
	while(1) {
		scanf("%s",buf);
		printf("recive %s\n", buf);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %edi, %edi
callq 0x1040
leaq 0xe7d(%rip), %rdi       # 0x2004
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x1050
leaq 0xe79(%rip), %rbx       # 0x2011
leaq -0x30(%rbp), %r14
leaq 0xe71(%rip), %r15       # 0x2014
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x11a3