LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/heap.c
// Function: heap_write
void heap_write(heap *h, FILE* f_out, pair value, int level){
  
  if(level){
    #if OUTPUT_BUFFER
      h->out_buffer[h->out_idx++]= value;
      if(h->out_idx==h->output_size){
        write_buffer(h, f_out, level);
        //fwrite(h->out_pair_buffer, sizeof(pair), h->out_idx, f_out);  
        //h->out_idx=0;
      }   
    #else
      //uint64_t pos = pos(value);
      //uint64_t lcp = lcp(value);
      //fwrite(&lcp, h->lcp_size, 1, f_out);
      //fwrite(&pos, h->pos_size, 1, f_out);
      fwrite(&value, h->pos_size+h->lcp_size, 1, f_out);
    #endif
  }
  else{
    #if OUTPUT_BUFFER   
      //h->out_lcp_buffer[h->out_idx] = value.lcp;
      h->out_buffer[h->out_idx++] = value;
      if(h->out_idx==h->output_size){
        write_buffer(h, f_out, level);
      }
    #else
      uint64_t lcp = lcp(value);
      fwrite(&lcp, h->lcp_size, 1, f_out);  
    #endif
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x3c50
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq 0x208(%rdi), %rax
movslq 0x210(%rdi), %rcx
movl %ecx, %r8d
incl %r8d
movl %r8d, 0x210(%rdi)
shlq $0x4, %rcx
movq %rsi, 0x8(%rax,%rcx)
movq %rdx, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq 0x210(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x228(%rcx), %rax
jne 0x3c4e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x3320
jmp 0x3cae
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq 0x208(%rdi), %rax
movslq 0x210(%rdi), %rcx
movl %ecx, %r8d
incl %r8d
movl %r8d, 0x210(%rdi)
shlq $0x4, %rcx
movq %rsi, 0x8(%rax,%rcx)
movq %rdx, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq 0x210(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x228(%rcx), %rax
jne 0x3cac
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x3320
jmp 0x3cae
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/utilities.c
// Function: initialize
int initialize(FILE *fileName, DocumentNode *documentArray){
    int maxLength = 1, curLength = 0, lineId = 0, docWords;
    char lineBuffer[100000], *newDoc;

    // start reading the file until EOF is read
    while(fgets(lineBuffer, 99999, fileName)){                  // read docfile contents
        strtok(lineBuffer, "\n");                               // remove the useless \n character at the end of the line

        curLength = strlen(lineBuffer);
        if( curLength > maxLength)
            maxLength = curLength;

        // every document will have the length of the line read
        newDoc = (char *) malloc(strlen(lineBuffer) +1);
        // copy the useful content (just the text) of lineBuffer to newDoc
        strcpy(newDoc, lineBuffer);

        docWords = 1;                                           // init at 1 so we don't have to increment it for this instance
        strtok(lineBuffer, "/");

        while((strtok(NULL, "/"))){                             // count the path's words
            docWords++;
        }

        addDocument(documentArray, lineId, newDoc, docWords);   // add document to our array
        lineId++;
    }
    return maxLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x186d0, %rsp          # imm = 0x186D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x186c0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x1869f, %esi          # imm = 0x1869F
callq 0x2180
cmpq $0x0, %rax
je 0x2998
leaq -0x186c0(%rbp), %rdi
leaq 0x2c45(%rip), %rsi      # 0x552a
callq 0x22f0
leaq -0x186c0(%rbp), %rdi
callq 0x20c0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x2907
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x186c0(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, -0x186c8(%rbp)
movq -0x186c8(%rbp), %rdi
leaq -0x186c0(%rbp), %rsi
callq 0x2050
movl $0x1, -0x20(%rbp)
leaq -0x186c0(%rbp), %rdi
leaq 0x2923(%rip), %rsi      # 0x5271
callq 0x22f0
xorl %eax, %eax
movl %eax, %edi
leaq 0x2913(%rip), %rsi      # 0x5271
callq 0x22f0
cmpq $0x0, %rax
je 0x2974
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2953
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x186c8(%rbp), %rdx
movl -0x20(%rbp), %ecx
callq 0x29b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x28b8
movl -0x14(%rbp), %eax
addq $0x186d0, %rsp          # imm = 0x186D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/utilities.c
// Function: destroyDocuments
void destroyDocuments(DocumentNode *documentNodes, int nLines){
    int i;

    for (i = 0;i < nLines; i++)
        free(documentNodes[i].text);
    free(documentNodes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2a30
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2a06
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/utilities.c
// Function: determineWorkload
int determineWorkload(int nDocs, int numWorkers, int *remainder){
    int increment = 0;

    if ((nDocs % numWorkers) == 0){
        increment = nDocs / numWorkers;            // determine how many files each worker will get
    }
    else if ((nDocs % numWorkers) > 0){
        increment = nDocs / numWorkers;
        (*remainder) = nDocs % numWorkers;
    }

    return increment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
cmpl $0x0, %edx
jne 0x2a6d
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2a92
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
cmpl $0x0, %edx
jle 0x2a90
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movq -0x10(%rbp), %rax
movl %edx, (%rax)
jmp 0x2a92
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/utilities.c
// Function: splitWorkload
int *splitWorkload(int increment, int *remainder, int numWorkers) {
    int i, *workerLoad;

    workerLoad = (int *) malloc(sizeof(int) * numWorkers);

    for(i = 0; i < numWorkers; i++){
        if(*remainder > 0) {
            workerLoad[i] = increment + 1;          // split the remainder between the workers
            (*remainder)--;
        }
        else
            workerLoad[i] = increment;
    }

    return workerLoad;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2250
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2b14
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x2af9
movl -0x4(%rbp), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x2b07
movl -0x4(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2b09
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2aca
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x248a(%rip), %rsi      # 0x552b
callq 0x21a0
cmpl $0x0, %eax
jne 0x30b4
movl $0x0, -0x4(%rbp)
jmp 0x311f
jmp 0x30b6
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x1d(%rbp)
jg 0x30d5
cmpl $0xa, -0x14(%rbp)
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x30de
jmp 0x3119
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x3102
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x3102
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x310b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x30b6
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x53b1(%rip), %rdi      # 0x85a8
callq 0x23d0
movq -0x8(%rbp), %rax
cmpl $0x32, 0x1390(%rax)
jl 0x321e
leaq 0x5418(%rip), %rdi      # 0x8628
leaq 0x5391(%rip), %rsi      # 0x85a8
callq 0x2090
jmp 0x31fc
movq -0x8(%rbp), %rax
movl 0x138c(%rax), %eax
addl $0x1, %eax
movl $0x32, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movl %edx, 0x138c(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x138c(%rax), %rax
imulq $0x64, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
movq -0x8(%rbp), %rax
movl 0x1390(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1390(%rax)
leaq 0x5332(%rip), %rdi      # 0x85a8
callq 0x2240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5305(%rip), %rdi      # 0x85a8
callq 0x23d0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1390(%rax)
jg 0x32d9
movl 0x53a5(%rip), %eax      # 0x8660
addl $0x1, %eax
movl %eax, 0x539c(%rip)      # 0x8660
leaq 0x532d(%rip), %rdi      # 0x85f8
leaq 0x52d6(%rip), %rsi      # 0x85a8
callq 0x2090
jmp 0x32a8
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x138c(%rcx), %rcx
imulq $0x64, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1388(%rax), %eax
addl $0x1, %eax
movl $0x32, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movl %edx, 0x1388(%rax)
movq -0x8(%rbp), %rax
movl 0x1390(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1390(%rax)
leaq 0x527c(%rip), %rdi      # 0x85a8
callq 0x2240
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/support.c
// Function: dirExists
int dirExists(char *dir){
    struct stat st = {0};

    if (stat(dir, &st) == -1) {                             // Does not exist
        return -1;
    }
    else
        return 0;                                           // Exists
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x2130
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x21f0
cmpl $-0x1, %eax
jne 0x3970
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3977
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x39c0
leaq 0x1bd7(%rip), %rdi      # 0x558d
callq 0x22e0
jmp 0x3a95
jmp 0x39c2
movq -0x10(%rbp), %rdi
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3a8c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x39e5
jmp 0x39c2
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x13, %rdi
callq 0x20c0
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
callq 0x2250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x18(%rbp), %rdi
addq $0x13, %rdi
leaq 0x1b56(%rip), %rsi      # 0x5585
callq 0x21a0
cmpl $0x0, %eax
je 0x3a52
movq -0x18(%rbp), %rdi
addq $0x13, %rdi
leaq 0x1b3c(%rip), %rsi      # 0x5584
callq 0x21a0
cmpl $0x0, %eax
jne 0x3a54
jmp 0x3a7e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x13, %rsi
callq 0x2330
movq -0x20(%rbp), %rdi
leaq 0x1801(%rip), %rsi      # 0x5271
callq 0x2330
movq -0x20(%rbp), %rdi
callq 0x4540
movq -0x20(%rbp), %rdi
callq 0x2030
jmp 0x39c2
movq -0x10(%rbp), %rdi
callq 0x2150
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq 0x14ca(%rip), %rsi      # 0x5489
movb $0x0, %al
callq 0x2340
movl -0x1c(%rbp), %eax
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x20c0
movl -0x21c(%rbp), %edi
movq -0x218(%rbp), %rsi
movl %eax, %edx
callq 0x3bc0
leaq -0x210(%rbp), %rdi
callq 0x20c0
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1473(%rip), %rsi      # 0x553d
callq 0x23c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/support.c
// Function: getContentLength
int getContentLength(char *buffer){
    int contLength;
    char *pos;

    pos = strstr(buffer, "Content-Length: ");
    pos = pos + 16;
    contLength = atoi(pos);

    return contLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1415(%rip), %rsi      # 0x552c
callq 0x23c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2320
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x318(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x2130
leaq -0x1b0(%rbp), %rdi
leaq 0x10ec(%rip), %rsi      # 0x5270
callq 0x2050
leaq -0x1b0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2330
leaq -0x1b0(%rbp), %rdi
leaq 0x10ca(%rip), %rsi      # 0x5271
callq 0x2330
leaq -0x1b0(%rbp), %rdi
leaq -0x318(%rbp), %rsi
callq 0x21f0
cmpl $-0x1, %eax
jne 0x41e8
leaq -0x1b0(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x2060
cmpl $-0x1, %eax
jne 0x41e6
leaq 0x136c(%rip), %rdi      # 0x554d
callq 0x22e0
jmp 0x41e8
leaq -0x280(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
leaq -0x280(%rbp), %rdi
leaq 0x106b(%rip), %rsi      # 0x5271
callq 0x22f0
movq %rax, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
callq 0x2330
leaq -0x1b0(%rbp), %rdi
leaq -0x318(%rbp), %rsi
callq 0x21f0
cmpl $-0x1, %eax
jne 0x4261
leaq -0x1b0(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x2060
cmpl $-0x1, %eax
jne 0x425f
leaq 0x1300(%rip), %rdi      # 0x555a
callq 0x22e0
jmp 0x4261
leaq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
leaq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2330
leaq -0xe0(%rbp), %rdi
leaq 0x12d8(%rip), %rsi      # 0x5567
callq 0x22d0
movq %rax, -0x288(%rbp)
cmpq $0x0, -0x288(%rbp)
jne 0x42b1
leaq 0x12be(%rip), %rdi      # 0x556a
callq 0x3910
movq -0x288(%rbp), %rax
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x125d(%rip), %rsi      # 0x5570
callq 0x23c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x43f8
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2050
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1237(%rip), %rsi      # 0x5579
leaq -0x38(%rbp), %rdx
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0xa, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x4420
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x11da(%rip), %rsi      # 0x557b
callq 0x2050
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2330
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x4490
cmpl $0x1, %eax
jne 0x43e0
movq -0x40(%rbp), %rdi
callq 0x4500
cmpl $0x0, %eax
jne 0x43e0
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x31e0
cmpq $0x0, -0x10(%rbp)
je 0x43f3
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x4308
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x48(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1149(%rip), %rsi      # 0x5584
callq 0x23c0
cmpq $0x0, %rax
je 0x4454
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x4478
movq -0x8(%rbp), %rdi
leaq 0xe11(%rip), %rsi       # 0x5270
callq 0x23c0
cmpq $0x0, %rax
je 0x4476
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4478
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1390(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x44ef
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x20(%rbp), %rax
imulq $0x64, %rax, %rax
addq %rax, %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x44e2
movl $0x0, -0x4(%rbp)
jmp 0x44f6
jmp 0x44e4
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x44b4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xdad(%rip), %rdi       # 0x5300
leaq 0x102d(%rip), %rsi      # 0x5587
callq 0x22d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4576
leaq 0xff9(%rip), %rdi       # 0x556a
callq 0x3910
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1004(%rip), %rsi      # 0x5589
movb $0x0, %al
callq 0x21d0
movq -0x10(%rbp), %rdi
callq 0x20a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x49d0
leaq -0x90(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0xc98(%rip), %rsi       # 0x55fd
movb $0x0, %al
callq 0x2340
leaq -0x50(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0xc93(%rip), %rsi       # 0x560d
movb $0x0, %al
callq 0x2340
leaq 0x3ce8(%rip), %rax      # 0x8670
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x2140
leaq 0x3cda(%rip), %rax      # 0x8678
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x2140
leaq -0x90(%rbp), %rdi
callq 0x2040
leaq -0x50(%rbp), %rdi
callq 0x2040
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x494c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x29f0
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x49e0
leaq 0xe83(%rip), %rax       # 0x758c
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a30
leaq -0xa0(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x6745
jmp 0x675c
movq -0x68(%rbp), %rdi
callq 0x6780
leaq -0xa0(%rbp), %rdi
callq 0x5800
jmp 0x6733
leaq -0xa0(%rbp), %rdi
callq 0x5cb0
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/basic.c
// Function: draw
static void draw(scg_image_t *draw_target) {
    int w = draw_target->width;
    int h = draw_target->height;
    float32_t inv_w = 1.0f / (float32_t)w;
    float32_t inv_h = 1.0f / (float32_t)h;

    for (int y = 0; y < h; y++) {
        for (int x = 0; x < w; x++) {
            uint8_t r = (int)((x * inv_w) * 255.0f) & 255;
            uint8_t g = (int)((y * inv_h) * 255.0f) & 255;

            scg_pixel_t color = scg_pixel_new_rgb(r, g, 128);
            scg_image_set_pixel(draw_target, x, y, color);
        }
    }

    scg_image_draw_string(draw_target, "Hello, World!", w / 2, h / 2, 1,
                          SCG_COLOR_WHITE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
cvtsi2ssl -0xc(%rbp), %xmm1
movss 0x85c(%rip), %xmm0      # 0x7008
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm1
movss 0x846(%rip), %xmm0      # 0x7008
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6872
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6862
cvtsi2ssl -0x20(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
movss 0x80d(%rip), %xmm1      # 0x700c
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
andl $0xff, %eax
movb %al, -0x21(%rbp)
cvtsi2ssl -0x1c(%rbp), %xmm0
mulss -0x18(%rbp), %xmm0
movss 0x7eb(%rip), %xmm1      # 0x700c
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
andl $0xff, %eax
movb %al, -0x22(%rbp)
movb $-0x80, -0x28(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x27(%rbp)
movb -0x21(%rbp), %al
movb %al, -0x26(%rbp)
movb $-0x1, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x2f60
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x67e5
jmp 0x6864
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x67d2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x30(%rbp), %edx
movl %eax, %ecx
movb $-0x1, -0x2c(%rbp)
movb $-0x1, -0x2b(%rbp)
movb $-0x1, -0x2a(%rbp)
movb $-0x1, -0x29(%rbp)
movl -0x2c(%rbp), %r9d
leaq 0x18e3(%rip), %rsi      # 0x8192
movl $0x1, %r8d
callq 0x4190
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x9d52(%rip), %rax      # 0xc180
movzbl (%rax,%rcx,8), %eax
cmpl $0x8f, %eax
je 0x24d9
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x9d29(%rip), %rax      # 0xc180
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x8f, %eax
jne 0x2475
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x24e0
cmpq $0x0, -0x18(%rbp)
jne 0x247e
jmp 0x24c9
movslq -0x1c(%rbp), %rcx
leaq 0x9cf7(%rip), %rax      # 0xc180
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23e0
movb %al, %cl
movl -0x24(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x24b2
jmp 0x24c9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x244c
jmp 0x24cb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2423
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2571
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2552
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x25b1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2592
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x18, %edi
callq 0x21e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x21e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x20a0
movw -0xa(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x266f
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x268b
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/endeav0r[P]hsvm/src/assembler.c
// Function: labels_search
struct _label * labels_search (struct _labels * labels, const char * needle)
{
    struct _label * next;
    for (next = labels->first; next != NULL; next = next->next) {
        if (strcmp(next->str, needle) == 0)
            return next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26e1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x26d1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26e9
jmp 0x26d3
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x26ab
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6878(%rip), %rsi      # 0x978f
callq 0x2270
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f50
movq 0x90ca(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x62d8(%rip), %rsi      # 0x9214
movb $0x0, %al
callq 0x21b0
movq $0x0, -0x8(%rbp)
jmp 0x2ff1
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2200
movq -0x18(%rbp), %rdi
callq 0x21c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2200
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x21e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x20c0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
callq 0x20e0
movq -0x28(%rbp), %rdi
callq 0x39c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2fe0
movq -0x10(%rbp), %rsi
leaq 0x6253(%rip), %rdi      # 0x922c
movb $0x0, %al
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6227(%rip), %rsi      # 0x9245
callq 0x2270
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3053
movq 0x8fc3(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x61d1(%rip), %rsi      # 0x9214
movb $0x0, %al
callq 0x21b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3079
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x22c0
movq -0x28(%rbp), %rdi
callq 0x20e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1hanuman120/ref/primate.cpp
// Function: T15(unsigned char)
unsigned char T15(unsigned char element) //Field Multiplication by 15 of an element
{
	unsigned char tmp, t2, t4, t8;
	t2=T2(element);
	t4=T2(t2);
	t8=T2(t4);
	tmp=t8^t4^t2^element; 
	return tmp;
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %edi
callq 0x10c0
movb %al, 0x5(%rsp)
movzbl 0x5(%rsp), %edi
callq 0x10c0
movb %al, 0x4(%rsp)
movzbl 0x4(%rsp), %edi
callq 0x10c0
movb %al, 0x3(%rsp)
movzbl 0x3(%rsp), %eax
movzbl 0x4(%rsp), %ecx
xorl %ecx, %eax
movzbl 0x5(%rsp), %ecx
xorl %ecx, %eax
movzbl 0x7(%rsp), %ecx
xorl %ecx, %eax
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x7, 0x2c(%rsp)
jge 0x2a90
movl $0x0, 0x28(%rsp)
cmpl $0x8, 0x28(%rsp)
jge 0x2a4c
movl $0x0, 0x24(%rsp)
cmpl $0x6, 0x24(%rsp)
jge 0x2935
movq 0x70(%rsp), %rax
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
shll $0x3, %ecx
addl 0x28(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl 0x24(%rsp), %eax
shll $0x3, %eax
addl 0x28(%rsp), %eax
cltq
movb %cl, 0x30(%rsp,%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x28f7
movq 0x70(%rsp), %rax
movslq 0x28(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x10c0
movb %al, %cl
movl 0x8(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x1140
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x1170
movb %al, %cl
movl 0x10(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x1170
movb %al, %cl
movl 0x14(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x28, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x1140
movb %al, %cl
movl 0x18(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x1c(%rsp)
movq 0x70(%rsp), %rax
movl 0x28(%rsp), %ecx
addl $0x30, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x10c0
movb %al, %cl
movl 0x1c(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb %al, %cl
movl 0x28(%rsp), %eax
addl $0x30, %eax
cltq
movb %cl, 0x30(%rsp,%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x28e4
movl $0x0, 0x20(%rsp)
cmpl $0x38, 0x20(%rsp)
jge 0x2a7e
movslq 0x20(%rsp), %rax
movb 0x30(%rsp,%rax), %dl
movq 0x70(%rsp), %rax
movslq 0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2a54
jmp 0x2a80
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x28d1
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x2ffa(%rip), %rdi      # 0x5184
movb $0x0, %al
callq 0x1050
leaq 0x3001(%rip), %rdi      # 0x5199
movb $0x0, %al
callq 0x1050
movq 0x20(%rsp), %rdi
movb 0x1f(%rsp), %al
movl $0x200, %esi            # imm = 0x200
andb $0x1, %al
movzbl %al, %edx
callq 0x1fc0
movq $0x8, 0x10(%rsp)
cmpq $0x200, 0x10(%rsp)      # imm = 0x200
ja 0x21f7
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movb 0x1f(%rsp), %al
movl $0x200, %esi            # imm = 0x200
andb $0x1, %al
movzbl %al, %ecx
callq 0x18e0
movq 0x10(%rsp), %rax
shlq %rax
movq %rax, 0x10(%rsp)
jmp 0x21c0
leaq 0x30ef(%rip), %rdi      # 0x52ed
movb $0x0, %al
callq 0x1050
leaq 0x2fa6(%rip), %rdi      # 0x51b2
movb $0x0, %al
callq 0x1050
movq 0x20(%rsp), %rdi
movb 0x1f(%rsp), %al
movl $0x80, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x1fc0
movq $0x8, 0x8(%rsp)
cmpq $0x80, 0x8(%rsp)
ja 0x226b
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
movb 0x1f(%rsp), %al
movl $0x80, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0x18e0
movq 0x8(%rsp), %rax
shlq %rax
movq %rax, 0x8(%rsp)
jmp 0x2234
leaq 0x307b(%rip), %rdi      # 0x52ed
movb $0x0, %al
callq 0x1050
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_expr.c
// Function: strcmpnull
static inline int strcmpnull(const char *a, const char *b) {
    if (!a && !b) return  0;
    if (!a &&  b) return -1;
    if (a  && !b) return  1;
    return strcmp(a, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x81e7
cmpq $0x0, -0x18(%rbp)
jne 0x81e7
movl $0x0, -0x4(%rbp)
jmp 0x8225
cmpq $0x0, -0x10(%rbp)
jne 0x81fe
cmpq $0x0, -0x18(%rbp)
je 0x81fe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8225
cmpq $0x0, -0x10(%rbp)
je 0x8215
cmpq $0x0, -0x18(%rbp)
jne 0x8215
movl $0x1, -0x4(%rbp)
jmp 0x8225
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x831d
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x4250
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x84e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x27e0(%rip), %rdx     # 0x5ac0
leaq -0x38(%rbp), %rcx
callq 0x8790
cmpl $0x0, %eax
je 0x82b7
movl $0x1, -0x4(%rbp)
jmp 0x8325
movsbl -0x37(%rbp), %ecx
leaq 0xe0431(%rip), %rsi     # 0xe86f3
leaq 0xdffb5(%rip), %rax     # 0xe827e
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0xe0472(%rip), %rdi     # 0xe8749
movb $0x0, %al
callq 0x4060
cmpb $0x0, -0x38(%rbp)
je 0x82ef
movq -0x20(%rbp), %rdi
callq 0x47b0
jmp 0x8302
movsd -0x18(%rbp), %xmm0
leaq 0xe0452(%rip), %rdi     # 0xe874d
movb $0x1, %al
callq 0x4060
leaq -0x38(%rbp), %rdi
callq 0x8230
movq -0x40(%rbp), %rdi
callq 0x8570
movl $0x0, -0x4(%rbp)
jmp 0x8325
callq 0x5e90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop