LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/functions.c
// Function: readFolder
void readFolder(char *path, TrieNode *trie, int *nWords, int *nChars, int *nLines){
    DIR *dp;
    struct dirent *dir;
    char *newName;
    if((dp = opendir(path)) == NULL){                       // Open directory
        perror("readfolder");
        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);
            readFile(newName, trie, nWords, nChars, nLines);
        }

        free(newName);
    }
    closedir(dp);                                           // Close directory
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, %r13
callq 0x1080
testq %rax, %rax
je 0x1572
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1100
testq %rax, %rax
je 0x155c
movq %rax, %r14
cmpq $0x0, (%rax)
je 0x14c1
movq %r13, %rdi
callq 0x1090
movq %rax, %r15
movq %r14, %r12
addq $0x13, %r12
movq %r12, %rdi
callq 0x1090
leaq (%r15,%rax), %rdi
addq $0x2, %rdi
callq 0x1110
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0x1040
cmpb $0x2e, 0x13(%r14)
jne 0x152c
cmpb $0x0, 0x14(%r14)
je 0x154f
cmpb $0x2e, 0x14(%r14)
jne 0x152c
cmpb $0x0, 0x15(%r14)
je 0x154f
movq %r15, %rdi
movq %r12, %rsi
callq 0x1170
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0x158c
movq %r15, %rdi
callq 0x1030
jmp 0x14c1
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
leaq 0xaf9(%rip), %rdi       # 0x2072
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1140
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/trie.c
// Function: insertWord
TrieNode * insertWord(TrieNode *root, char* word, int lineNumber, char *fileName){
    TrieNode *current = root;
    int newDoc;

    while (*word){                                     // while not all the string has been consumed
        current = findNextTrieNode(current, *word, 0); // go to the trie node that contains the current letter
        word++;                                        // point to next letter
    }

    current->frequency++;                              // increase the frequency of this word (current is pointing to the leaf node (aka where the word is)
    if (current->postingList == NULL){                 // if there is no posting list yet for this word
        current->postingList = createPostingList(lineNumber, fileName); // create it
        newDoc = 1;
    }
    else
        current->postingList = addToPostingList(current->postingList, lineNumber, &newDoc, fileName); // insert the doc id to the beginning of the inverted index of the word

    current->nDocs += newDoc;                           // will be incremented by one, if this was the first appearance of the word in the lineNumber

    return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movb (%r12), %al
testb %al, %al
je 0x1962
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19aa
movq %rax, %rbx
incq %r12
jmp 0x1945
incl (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1985
leaq -0x24(%rbp), %r12
movl %r15d, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1ac0
movl (%r12), %ecx
jmp 0x1993
movl %r15d, %edi
movq %r14, %rsi
callq 0x1a67
pushq $0x1
popq %rcx
movq %rax, 0x10(%rbx)
addl %ecx, 0x4(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/trie.c
// Function: createPostingList
PostingListNode * createPostingList(int lineNumber, char *fileName){

    PostingListNode *newNode = (PostingListNode*) malloc(sizeof(PostingListNode));
    newNode->fileName = (char *) malloc(strlen(fileName) + 1);

    newNode->lineNumber = lineNumber;
    newNode->n          = 1;
    //    newNode->fileName   = fileName;
    strcpy(newNode->fileName, fileName);
    newNode->next       = NULL;

    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
pushq $0x18
popq %rdi
callq 0x1110
movq %rax, %r15
movq %rbx, %rdi
callq 0x1090
leaq 0x1(%rax), %rdi
callq 0x1110
movq %rax, (%r15)
movl %r14d, 0x8(%r15)
movl $0x1, 0xc(%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1040
andq $0x0, 0x10(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/trie.c
// Function: addToPostingList
PostingListNode * addToPostingList(PostingListNode *head, int lineNumber, int *newDoc, char *fileName){
    PostingListNode *newNode, *lineNode;

    if(!strcmp(head->fileName, fileName) && (head->lineNumber == lineNumber)) {
        (head->n)++;            // simply increase frequency

        *newDoc = 0;            // do not count this doc as new doc the word has appeared into

        return head;
    }
    else if (!strcmp(head->fileName, fileName) && (head->lineNumber != lineNumber)){  // if this is not the first time the word is found in the document /head->fileName == fileName
        lineNode = (PostingListNode *) malloc(sizeof(PostingListNode));
        lineNode->fileName = (char *) malloc(strlen(fileName) + 2);

        lineNode->lineNumber = lineNumber;
        lineNode->n = head->n + 1;
        strcpy(lineNode->fileName, fileName);
        lineNode->next       = head;

        *newDoc = 0;            // do not count this doc as new doc the word has appeared into

        return lineNode;            // head remains as is
    }
    else{                       // if this is the first time the word is found in the document
        newNode = (PostingListNode *) malloc(sizeof(PostingListNode));
        newNode->fileName = (char *) malloc(strlen(fileName) + 2);

        newNode->lineNumber = lineNumber;   // node points to the document the word is in
        newNode->n          = 1;            // frequency of the word inside the document is 1, since it is its first appearance
//        newNode->fileName   = fileName;     // set the fileName
        strcpy(newNode->fileName, fileName);
        newNode->next       = head;         // next node of the new node is the old head

        *newDoc = 1;            // make sure we count this doc in the unique docs the word has appeared

        return newNode;         // new node becomes the new head of the list
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r14
movq (%rdi), %rdi
movq %rcx, %rsi
callq 0x10f0
testl %eax, %eax
je 0x1b29
pushq $0x18
popq %rdi
callq 0x1110
movq %rax, %r13
movq %r15, %rdi
callq 0x1090
leaq 0x2(%rax), %rdi
callq 0x1110
movq %rax, (%r13)
movl %r12d, 0x8(%r13)
movl $0x1, 0xc(%r13)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
movq %r14, 0x10(%r13)
pushq $0x1
popq %rax
jmp 0x1b76
cmpl %r12d, 0x8(%r14)
jne 0x1b37
incl 0xc(%r14)
xorl %eax, %eax
jmp 0x1b79
pushq $0x18
popq %rdi
callq 0x1110
movq %rax, %r13
movq %r15, %rdi
callq 0x1090
leaq 0x2(%rax), %rdi
callq 0x1110
movq %rax, (%r13)
movl %r12d, 0x8(%r13)
movl 0xc(%r14), %ecx
incl %ecx
movl %ecx, 0xc(%r13)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
movq %r14, 0x10(%r13)
xorl %eax, %eax
movq %r13, %r14
movl %eax, (%rbx)
movq %r14, %rax
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/trie.c
// Function: searchTrie
TrieNode * searchTrie(TrieNode *root, char *word){
    TrieNode *curNode = root;

    if (!word)
        return NULL;

    while (*word && curNode){                          // while not all the string has been consumed
        curNode = findNextTrieNode(curNode, *word, 1); // go to the trie node that contains the current letter
        word++;                                        // go to next letter
    }

    return curNode;
}

// Assembly:
testq %rsi, %rsi
je 0x1bc6
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
pushq $0x1
popq %r14
movb (%rbx), %cl
testb %cl, %cl
je 0x1bc1
testq %rax, %rax
je 0x1bc1
movsbl %cl, %esi
movq %rax, %rdi
movl %r14d, %edx
callq 0x19aa
incq %rbx
jmp 0x1ba3
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/trie.c
// Function: getPostingList
PostingListNode * getPostingList(TrieNode *root, char *word){
    TrieNode *node = searchTrie(root, word);

    if (node)
        return node->postingList;
    else
        return NULL;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1b8d
testq %rax, %rax
je 0x1bdd
movq 0x10(%rax), %rax
jmp 0x1bdf
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/trie.c
// Function: destroyTrie
void destroyTrie(TrieNode *trieNode){
    TrieNodeList *cur, *prev;

    if (!trieNode)
        return;

    cur = prev = trieNode->charList;

    while (cur){
        destroyTrie(cur->node);
        cur = cur->next;
        free(prev);
        prev = cur;
    }

    destroyPostingList(trieNode->postingList);
    free(trieNode);
}

// Assembly:
testq %rdi, %rdi
je 0x1c31
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1c16
movq 0x8(%r14), %rdi
callq 0x1be1
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
jmp 0x1bf7
movq 0x10(%rbx), %rdi
callq 0x1c32
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/trie.c
// Function: destroyPostingList
void destroyPostingList(PostingListNode *postingListNode){
    if (!postingListNode)
        return;

    destroyPostingList(postingListNode->next);
    free(postingListNode->fileName);
    free(postingListNode);
}

// Assembly:
testq %rdi, %rdi
je 0x1c5f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1c32
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/trie.c
// Function: getDocFrequency
int getDocFrequency(PostingListNode *head, char *fileName){
    PostingListNode *curNode = head;

    while (curNode){                     // while there are nodes to search

        if (!strcmp(fileName,curNode->fileName))    // if doc node is found
            return curNode->n;           // return frequency
        else if (strcmp(fileName,curNode->fileName) != 0) // if there are more nodes to search
            curNode = curNode->next;     // go to next
        else                             // else (there are more nodes actually, but since the list is in DESCENDING ORDER, there is no point to look further)
            return 0;                    // return zero (no such word found in specific doc id)
    }

    return 0;                            // default zero return value
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x1c87
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x1c8b
movq 0x10(%rbx), %rbx
jmp 0x1c6d
xorl %eax, %eax
jmp 0x1c8e
movl 0xc(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/helpers.c
// Function: isDuplicate
int isDuplicate(WordSearchNode *head, char *word){
    WordSearchNode *cur = head;
    int found = 0;

    while (cur && !found) {
        if (!strcmp(cur->word, word))
            found = 1;
        cur = cur->next;
    }

    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %r14, %r14
je 0x1cc7
testl %eax, %eax
jne 0x1cc7
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movq 0x20(%r14), %r14
jmp 0x1ca3
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/helpers.c
// Function: destroyWordSearchNodes
void destroyWordSearchNodes(WordSearchNode *head){
    WordSearchNode *curNode = head, *prevNode = head;

    while (curNode){
        curNode = curNode->next;
        free(prevNode->word);
        free(prevNode->fileName);
        free(prevNode->contents);
        free(prevNode);
        prevNode = curNode;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x1ed3
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r14
callq 0x1030
movq (%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
jmp 0x1ea3
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/devkot[P]SearchEngine/Crawler/helpers.c
// Function: readLine
char *readLine(char *fileName, int lineNumber){
    FILE *file;
    char lineBuffer[100000], *line = NULL;
    int curLine = 0;

    file = fopen(fileName, "r");                        // Open file

    if (file == NULL){
        perror("fopen");
        exit(EXIT_FAILURE);
    }

    while(fgets(lineBuffer, 99999, file)) {
        if(curLine == lineNumber) {                     // read the line we need
            line = (char *) malloc(strlen(lineBuffer) + 1);
            strcpy(line, lineBuffer);                   // copy our desired line from buffer
            break;
        }
        curLine++;
    }

    fclose(file);
    return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x186a0, %rsp          # imm = 0x186A0
movl %esi, %r14d
leaq 0x187(%rip), %rsi       # 0x207b
callq 0x1130
testq %rax, %rax
je 0x1f69
movq %rax, %rbx
incl %r14d
leaq -0x186c0(%rbp), %r12
xorl %r15d, %r15d
movq %r12, %rdi
movl $0x1869f, %esi          # imm = 0x1869F
movq %rbx, %rdx
callq 0x10d0
testq %rax, %rax
je 0x1f4e
decl %r14d
jne 0x1f0e
leaq -0x186c0(%rbp), %r14
movq %r14, %rdi
callq 0x1090
leaq 0x1(%rax), %rdi
callq 0x1110
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1040
movq %rbx, %rdi
callq 0x1070
movq %r15, %rax
addq $0x186a0, %rsp          # imm = 0x186A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b4(%rip), %rdi       # 0x2124
callq 0x1140
pushq $0x1
popq %rdi
callq 0x1190
// File: /workspace/github_c_makefile_star2_O2/LuaJIT[P]LuaJIT/src/host/minilua.c
// Function: luaH_get
static const TValue*luaH_get(Table*t,const TValue*key){
switch(ttype(key)){
case 0:return(&luaO_nilobject_);
case 4:return luaH_getstr(t,rawtsvalue(key));
case 3:{
int k;
lua_Number n=nvalue(key);
lua_number2int(k,n);
if(luai_numeq(cast_num(k),nvalue(key)))
return luaH_getnum(t,k);
}
/*fallthrough*/
default:{
Node*n=mainposition(t,key);
do{
if(luaO_rawequalObj(key2tval(n),key))
return gval(n);
else n=gnext(n);
}while(n);
return(&luaO_nilobject_);
}
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rsi), %eax
leaq 0xb270(%rip), %rbx      # 0x12440
testl %eax, %eax
je 0x7237
movq %rsi, %r14
cmpl $0x3, %eax
je 0x71ee
cmpl $0x4, %eax
jne 0x720e
movq (%r14), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5042
movsd (%r14), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x720e
jp 0x720e
cvttsd2si %xmm0, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7269
movq %r14, %rsi
callq 0x72b7
movq %rax, %r15
leaq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x731f
testl %eax, %eax
jne 0x7234
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x7219
jmp 0x7237
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: gcalloc
struct object  *gcalloc(int size)
{
  struct object  *result;

  result = malloc(sizeof(struct object) + size * sizeof(struct object *));
  if(result == 0)
  {
    sysError("out of memory", "gcalloc");
  }
  SETSIZE(result, size);
  while(size > 0)
  {
    result->data[--size] = nilObject;
  }
  return result;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movslq %edi, %rax
leaq 0x10(,%rax,8), %rdi
callq 0x10f0
testq %rax, %rax
je 0x12c3
leal (,%rbx,4), %ecx
movl %ecx, (%rax)
movq 0x5e8f(%rip), %rcx      # 0x7140
movl %ebx, %edx
testl %edx, %edx
jle 0x12c1
movq %rcx, 0x8(%rax,%rdx,8)
decq %rdx
jmp 0x12b3
popq %rbx
retq
leaq 0x2d4d(%rip), %rdi      # 0x4017
leaq 0x2d54(%rip), %rsi      # 0x4025
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseError
int parseError(char *msg)
{
  char           *q;

  for(q = inputBuffer; q != p;)
    printf("%c", *q++);
  printf("\n%s\n", msg);
  while(*q)
    printf("%c", *q++);
  printf("\n");
  exit(1);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5e53(%rip), %r14      # 0x7150
cmpq 0x6e4c(%rip), %r14      # 0x8150
je 0x1314
movsbl (%r14), %edi
incq %r14
callq 0x1040
jmp 0x12fd
leaq 0x2d12(%rip), %rdi      # 0x402d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10a0
movsbl (%r14), %edi
testl %edi, %edi
je 0x1337
incq %r14
callq 0x1040
jmp 0x1325
pushq $0xa
popq %rdi
callq 0x1040
pushq $0x1
popq %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: addGlobalName
void addGlobalName(char *name, struct object *value)
{
  char           *newName;

  newName = strdup(name);
  if(!newName)
  {
    sysError("out of memory", "newname in add global");
  }
  globalNames[globalTop] = newName;
  globals[globalTop] = value;
  globalTop++;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x1160
testq %rax, %rax
je 0x137d
movslq 0x6dfc(%rip), %rcx      # 0x8158
leaq 0x6dfd(%rip), %rdx      # 0x8160
movq %rax, (%rdx,%rcx,8)
leaq 0x1a672(%rip), %rax     # 0x1b9e0
movq %rbx, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x6ddd(%rip)      # 0x8158
popq %rbx
retq
leaq 0x2c93(%rip), %rdi      # 0x4017
leaq 0x2ca7(%rip), %rsi      # 0x4032
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: lookupGlobal
struct object  *lookupGlobal(char *name, int ok_missing)
{
  int             i;

  for(i = 0; i < globalTop; i++)
  {
    if(strcmp(name, globalNames[i]) == 0)
    {
      return globals[i];
    }
  }
  /*
     not found, return 0 
   */
  if(!ok_missing)
  {
    sysError("Missing global", name);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x6db4(%rip), %r15d     # 0x8158
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
shlq $0x3, %r15
leaq 0x6da7(%rip), %r12      # 0x8160
cmpq %r14, %r15
je 0x13e0
movq (%r14,%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
addq $0x8, %r14
testl %eax, %eax
jne 0x13b9
leaq 0x1a607(%rip), %rax     # 0x1b9e0
movq -0x8(%r14,%rax), %rax
jmp 0x13e6
testl %ebp, %ebp
je 0x13ef
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c52(%rip), %rdi      # 0x4048
movq %rbx, %rsi
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: lstReadOneCharacter
LstInt lstReadOneCharacter()
{
  int c = '\r';

  while(c == '\r')
    c = fgetc(fin);
  if (c == '\n') lineNo++;

  return c;
}

// Assembly:
pushq %rax
pushq $0xd
popq %rax
cmpl $0xd, %eax
jne 0x1415
movq 0x2de52(%rip), %rdi     # 0x2f260
callq 0x10b0
jmp 0x1402
cmpl $0xa, %eax
jne 0x1420
incl 0x2de48(%rip)           # 0x2f268
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: inputMethodText
void inputMethodText()
{
  char            c;
  methodLineNo = lineNo;

  p = inputBuffer;
  while(1)
  {
    while((c = lstReadOneCharacter()) != '\n')
      *p++ = c;
    *p++ = '\n';
    if((c = lstReadOneCharacter()) == '!')
    {
      if((c = lstReadOneCharacter()) == '\n')
      {
        *p = '\0';
        return;
      }
      *p++ = '!';
      *p++ = c;
    }
    else
      *p++ = c;
  }
}

// Assembly:
pushq %rax
movl 0x2de3f(%rip), %eax     # 0x2f268
movl %eax, 0x2de3d(%rip)     # 0x2f26c
leaq 0x5d1a(%rip), %rax      # 0x7150
movq %rax, 0x6d13(%rip)      # 0x8150
callq 0x13fe
cmpb $0xa, %al
jne 0x1482
movq 0x6d03(%rip), %rax      # 0x8150
leaq 0x1(%rax), %rcx
movq %rcx, 0x6cf8(%rip)      # 0x8150
movb $0xa, (%rax)
callq 0x13fe
cmpb $0x21, %al
jne 0x1482
callq 0x13fe
movq 0x6ce0(%rip), %rcx      # 0x8150
cmpb $0xa, %al
je 0x1498
leaq 0x1(%rcx), %rdx
movq %rdx, 0x6cd1(%rip)      # 0x8150
movb $0x21, (%rcx)
movq 0x6cc7(%rip), %rcx      # 0x8150
leaq 0x1(%rcx), %rdx
movq %rdx, 0x6cbc(%rip)      # 0x8150
movb %al, (%rcx)
jmp 0x143d
movb $0x0, (%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: skipSpaces
void skipSpaces()
{
  while((*p == ' ') || (*p == '\t') || (*p == '\n') || (*p == '\r'))
    p++;
  if(*p == '\"')
  {
    p++;
    while(*p && (*p != '\"'))
      p++;
    if(*p != '\"')
      parseError("unterminated comment");
    p++;
    skipSpaces();
  }
}

// Assembly:
pushq %rax
movq 0x6cab(%rip), %rax      # 0x8150
movabsq $0x100002600, %rcx      # imm = 0x100002600
movzbl (%rax), %edx
cmpq $0x22, %rdx
ja 0x14f5
btq %rdx, %rcx
jae 0x14ca
incq %rax
movq %rax, 0x6c88(%rip)      # 0x8150
jmp 0x14af
cmpq $0x22, %rdx
jne 0x14f5
incq %rax
movq %rax, 0x6c76(%rip)      # 0x8150
movzbl (%rax), %edx
incq %rax
cmpl $0x22, %edx
je 0x14c1
testl %edx, %edx
jne 0x14d3
leaq 0x2b67(%rip), %rdi      # 0x4057
callq 0x12ef
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: readBinary
void readBinary()
{
  tokenBuffer[0] = *p++;
  if(isBinary(*p))
  {
    tokenBuffer[1] = *p++;
    tokenBuffer[2] = '\0';
  }
  else
    tokenBuffer[1] = '\0';
  skipSpaces();
}

// Assembly:
pushq %rbx
movq 0x6c13(%rip), %rbx      # 0x8150
leaq 0x1(%rbx), %rax
movq %rax, 0x6c08(%rip)      # 0x8150
movb (%rbx), %al
movb %al, 0x2dd20(%rip)      # 0x2f270
movsbl 0x1(%rbx), %edi
callq 0x1517
testl %eax, %eax
je 0x1574
leaq 0x2(%rbx), %rax
movq %rax, 0x6be8(%rip)      # 0x8150
movb 0x1(%rbx), %al
movb $0x0, 0x2dd00(%rip)     # 0x2f272
jmp 0x1576
xorl %eax, %eax
movb %al, 0x2dcf5(%rip)      # 0x2f271
popq %rbx
jmp 0x149d
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: readIdentifier
int readIdentifier()
{
  int             keyflag;
  char           *q = tokenBuffer;

  while(isIdentifierChar(*p) || isDigit(*p))
    *q++ = *p++;
  *q = '\0';
  if(*p == ':')
  {                             /* It's a keyword identifier */
    keyflag = 1;
    *q++ = ':';
    *q = '\0';
    p++;
  }
  else
    keyflag = 0;
  skipSpaces();
  return keyflag;
}

// Assembly:
pushq %rbx
movq 0x6bc6(%rip), %rax      # 0x8150
incq %rax
leaq 0x2dcdc(%rip), %rcx     # 0x2f270
movb -0x1(%rax), %dl
leal -0x3a(%rdx), %esi
cmpb $-0xb, %sil
ja 0x15ab
andb $-0x21, %dl
addb $-0x5b, %dl
cmpb $-0x1a, %dl
jb 0x15bf
movq %rax, 0x6b9e(%rip)      # 0x8150
movb -0x1(%rax), %dl
movb %dl, (%rcx)
incq %rcx
incq %rax
jmp 0x1594
movb $0x0, (%rcx)
xorl %ebx, %ebx
cmpb $0x3a, -0x1(%rax)
jne 0x15d9
movw $0x3a, (%rcx)
movq %rax, 0x6b7a(%rip)      # 0x8150
pushq $0x1
popq %rbx
callq 0x149d
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: readInteger
int readInteger()
{
  int             val,
                  neg = 0;

  if(*p == '-')
  {
    neg = 1;
    ++p;
  }
  val = *p++ - '0';
  while(isDigit(*p))
  {
    val = 10 * val + (*p++ - '0');
  }
  skipSpaces();
  return neg ? -val : val;

}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x6b64(%rip), %rax      # 0x8150
movb (%rax), %bl
xorl %ecx, %ecx
cmpb $0x2d, %bl
sete %cl
addq %rcx, %rax
incq %rax
movq %rax, 0x6b4d(%rip)      # 0x8150
movsbl -0x1(%rax), %ebp
addl $-0x30, %ebp
movb (%rax), %cl
addb $-0x3a, %cl
cmpb $-0xa, %cl
jb 0x1630
imull $0xa, %ebp, %ecx
leaq 0x1(%rax), %rdx
movq %rdx, 0x6b2e(%rip)      # 0x8150
movsbl (%rax), %eax
leal (%rcx,%rax), %ebp
addl $-0x30, %ebp
movq %rdx, %rax
jmp 0x160a
callq 0x149d
movl %ebp, %eax
negl %eax
cmpb $0x2d, %bl
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newSymbol
struct object  *newSymbol(char *text)
{
  LstUInt            i;
  struct byteObject *result;

  /*
     first see if it is already a symbol 
   */
  for(i = 0; i < symbolTop; i++)
  {
    if(symbolBareCmp
       ((char *) text, strlen(text), (char *) bytePtr(oldSymbols[i]),
        SIZE(oldSymbols[i])) == 0)
    {
      return oldSymbols[i];
    }
  }

  /*
     not there, make a new one 
   */
  result = binaryAlloc(strlen(text)); /* FIXME: Shouldn't we allocate one more byte? */
  for(i = 0; i < strlen(text); i++)
  {
    result->bytes[i] = text[i];
  }
  result->bytes[i] = 0;
  result->class = lookupGlobal("Symbol", 0);
  oldSymbols[symbolTop++] = (struct object *) result;
  return (struct object *) result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x2dc15(%rip), %r13d    # 0x2f2c0
callq 0x1090
movq %rax, %r15
shlq $0x3, %r13
xorl %ebp, %ebp
leaq 0x2dc10(%rip), %r12     # 0x2f2d0
cmpq %rbp, %r13
je 0x16e9
movq (%rbp,%r12), %r14
leaq 0x10(%r14), %rdx
movl (%r14), %ecx
shrl $0x2, %ecx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1646
addq $0x8, %rbp
testl %eax, %eax
jne 0x16c0
jmp 0x173c
movl %r15d, %edi
callq 0x12d6
movq %rax, %r14
movq %rbx, %rdi
callq 0x1090
xorl %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x1711
movb (%rbx,%rcx), %dl
movb %dl, 0x10(%r14,%rcx)
incl %ecx
jmp 0x16fe
movb $0x0, 0x10(%r14,%rcx)
leaq 0x294e(%rip), %rdi      # 0x406c
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%r14)
movl 0x2db91(%rip), %eax     # 0x2f2c0
leal 0x1(%rax), %ecx
movl %ecx, 0x2db88(%rip)     # 0x2f2c0
movq %r14, (%r12,%rax,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newNode
struct object  *newNode(struct object *v, struct object *l, struct object *r)
{
  struct object  *result;

  result = gcalloc(3);
  result->class = lookupGlobal("Node", 0);
  result->data[0] = v;
  result->data[1] = l;
  result->data[2] = r;
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x3
popq %rdi
callq 0x1289
movq %rax, %r12
leaq 0x28d9(%rip), %rdi      # 0x4073
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%r12)
movq %r15, 0x10(%r12)
movq %r14, 0x18(%r12)
movq %rbx, 0x20(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newDictionary
struct object  *newDictionary(void)
{
  struct object  *result;

  result = gcalloc(2);
  result->class = lookupGlobal("Dictionary", 0);
  result->data[0] = newOrderedArray();
  result->data[1] = newArray(0);
  return result;
}

// Assembly:
pushq %rbx
pushq $0x2
popq %rdi
callq 0x1289
movq %rax, %rbx
leaq 0x2883(%rip), %rdi      # 0x407d
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%rbx)
callq 0x181e
movq %rax, 0x10(%rbx)
xorl %edi, %edi
callq 0x1840
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newArray
struct object  *newArray(int size)
{
  struct object  *result;
  int             i;

  result = gcalloc(size);
  result->class = lookupGlobal("Array", 0);
  for(i = 0; i < size; ++i)
  {
    result->data[i] = nilObject;
  }
  return (result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x1289
movq %rax, %r14
leaq 0x28f4(%rip), %rdi      # 0x414a
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%r14)
movq 0x58d5(%rip), %rax      # 0x7140
testl %ebx, %ebx
cmovlel %r15d, %ebx
cmpq %r15, %rbx
je 0x1880
movq %rax, 0x10(%r14,%r15,8)
incq %r15
jmp 0x1871
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: genVal
void genVal(int v)
{
  if((v < 0) || (v > 0xFFFF))
  {
    sysError("illegal value", "");
  }
  genByte(v & 0xFF);
  genByte(v >> 8);
}

// Assembly:
pushq %rbx
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x18de
movl %edi, %ebx
movzbl %bl, %edi
callq 0x1889
shrl $0x8, %ebx
movl %ebx, %edi
popq %rbx
jmp 0x1889
leaq 0x27b6(%rip), %rdi      # 0x409b
leaq 0x2c4a(%rip), %rsi      # 0x4536
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: genValPos
void genValPos(int pos, int v)
{
  if((v < 0) || (v > 0xFFFF))
  {
    sysError("illegal value", "");
  }
  byteBuffer[pos] = v & 0xFF;
  byteBuffer[pos + 1] = v >> 8;
}

// Assembly:
cmpl $0x10000, %esi          # imm = 0x10000
jae 0x1908
movslq %edi, %rax
leaq 0x3760d(%rip), %rcx     # 0x38f10
movw %si, (%rax,%rcx)
retq
pushq %rax
leaq 0x278b(%rip), %rdi      # 0x409b
leaq 0x2c1f(%rip), %rsi      # 0x4536
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: buildByteArray
struct object  *buildByteArray()
{
  struct byteObject *newObj;
  LstUInt            i;

  newObj = binaryAlloc(byteTop);
  for(i = 0; i < byteTop; i++)
    newObj->bytes[i] = byteBuffer[i];
  newObj->class = lookupGlobal("ByteArray", 0);
  return (struct object *) newObj;
}

// Assembly:
pushq %rbx
movl 0x377cd(%rip), %edi     # 0x39110
callq 0x12d6
movq %rax, %rbx
movl 0x377bf(%rip), %eax     # 0x39110
xorl %ecx, %ecx
leaq 0x375b6(%rip), %rdx     # 0x38f10
cmpq %rax, %rcx
jae 0x196d
movb (%rcx,%rdx), %sil
movb %sil, 0x10(%rbx,%rcx)
incq %rcx
jmp 0x195a
leaq 0x2735(%rip), %rdi      # 0x40a9
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: addLiteral
int addLiteral(struct object *a)
{
  litBuffer[litTop++] = a;
  if(litTop >= LiteralBufferTop)
  {
    sysError("too many literals", "");
  }
  return litTop - 1;
}

// Assembly:
movl 0x3778a(%rip), %eax     # 0x39114
leal 0x1(%rax), %ecx
movl %ecx, 0x37781(%rip)     # 0x39114
leaq 0x37786(%rip), %rdx     # 0x39120
movq %rdi, (%rdx,%rax,8)
cmpl $0x64, %ecx
jae 0x19a4
retq
pushq %rax
leaq 0x2707(%rip), %rdi      # 0x40b3
leaq 0x2b83(%rip), %rsi      # 0x4536
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: buildLiteralArray
struct object  *buildLiteralArray(void)
{
  LstUInt         i;
  struct object  *result;

  if(litTop == 0)
    return nilObject;
  result = gcalloc(litTop);
  result->class = lookupGlobal("Array", 0);
  for(i = 0; i < litTop; i++)
    result->data[i] = litBuffer[i];
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x37752(%rip), %edi     # 0x39114
testl %edi, %edi
je 0x1a08
callq 0x1289
movq %rax, %rbx
leaq 0x2775(%rip), %rdi      # 0x414a
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%rbx)
movl 0x3772b(%rip), %eax     # 0x39114
shlq $0x3, %rax
leaq 0x3772c(%rip), %rcx     # 0x39120
cmpq %r14, %rax
je 0x1a0f
movq (%r14,%rcx), %rdx
movq %rdx, 0x10(%rbx,%r14)
addq $0x8, %r14
jmp 0x19f4
movq 0x5731(%rip), %rbx      # 0x7140
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: addArgument
void addArgument(char *name)
{
  char           *p;

  p = strdup(name);
  if(!p)
  {
    sysError("malloc failure", "addArguments");
  }
  argumentNames[argumentTop++] = p;
}

// Assembly:
pushq %rax
callq 0x1160
testq %rax, %rax
je 0x1a42
movslq 0x37b04(%rip), %rcx     # 0x39530
leal 0x1(%rcx), %edx
movl %edx, 0x37afb(%rip)     # 0x39530
leaq 0x37a04(%rip), %rdx     # 0x39440
movq %rax, (%rdx,%rcx,8)
popq %rax
retq
leaq 0x267c(%rip), %rdi      # 0x40c5
leaq 0x2684(%rip), %rsi      # 0x40d4
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: addTemporary
void addTemporary(char *name)
{
  char           *p;

  p = strdup(name);
  if(!p)
  {
    sysError("malloc failure", "addTemporary");
  }
  tempBuffer[tempTop++] = p;
  if(tempTop > maxTemp)
  {
    maxTemp = tempTop;
  }
}

// Assembly:
pushq %rax
callq 0x1160
testq %rax, %rax
je 0x1a8b
movslq 0x38a79(%rip), %rdx     # 0x3a4e0
leal 0x1(%rdx), %ecx
movl %ecx, 0x38a70(%rip)     # 0x3a4e0
leaq 0x37ac9(%rip), %rsi     # 0x39540
movq %rax, (%rsi,%rdx,8)
cmpl 0x38a63(%rip), %edx     # 0x3a4e4
jl 0x1a89
movl %ecx, 0x38a5b(%rip)     # 0x3a4e4
popq %rax
retq
leaq 0x2633(%rip), %rdi      # 0x40c5
leaq 0x2648(%rip), %rsi      # 0x40e1
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseInteger
int parseInteger(void)
{
  int             i;

  i = readInteger();
  if((i >= 0) && (i < 10))
  {
    genInstruction(PushConstant, i);
  }
  else
  {
    genInstruction(PushLiteral, addLiteral(newInteger(i)));
  }
  return 1;
}

// Assembly:
pushq %rax
callq 0x15e2
cmpl $0x9, %eax
ja 0x1dbc
pushq $0x5
jmp 0x1dcd
cltq
leaq 0x1(,%rax,2), %rdi
callq 0x1984
pushq $0x4
popq %rdi
movl %eax, %esi
callq 0x191c
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseTerm
int parseTerm(void)
{
  /*
     make it so anything other than a block zeros out backup var 
   */
  blockbackup = 0;
  superMessage = 0;

  if(*p == '(')
  {
    p++;
    skipSpaces();
    if(!parseExpression())
      return 0;
    if(*p != ')')
      return parseError("unbalanced parenthesis");
    p++;
    skipSpaces();
    return 1;
  }
  if(*p == '<')
    return parsePrimitive();
  if(*p == '$')
    return parseChar();
  if(isDigit(*p) || (*p == '-'))
    return parseInteger();
  if(*p == '\'')
    return parseString();
  if(isIdentifierChar(*p))
  {
    readIdentifier();
    return nameTerm(tokenBuffer);
  }
  if(*p == '[')
    return parseBlock();
  if(*p == '#')
    return parseSymbol();
  return parseError("illegal start of expression");
}

// Assembly:
pushq %rax
andq $0x0, 0x386e8(%rip)     # 0x3a550
andl $0x0, 0x386c9(%rip)     # 0x3a538
movq 0x62da(%rip), %rcx      # 0x8150
movzbl (%rcx), %eax
cmpl $0x24, %eax
je 0x1ec0
cmpl $0x3c, %eax
je 0x1eb9
cmpl $0x28, %eax
jne 0x1ec7
incq %rcx
movq %rcx, 0x62be(%rip)      # 0x8150
callq 0x149d
callq 0x24cf
movq 0x62ad(%rip), %rax      # 0x8150
cmpb $0x29, (%rax)
jne 0x1f22
incq %rax
movq %rax, 0x629e(%rip)      # 0x8150
callq 0x149d
jmp 0x1ede
callq 0x1dda
jmp 0x1ede
callq 0x2466
jmp 0x1ede
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x1ed9
cmpl $0x27, %eax
je 0x1ee3
cmpl $0x2d, %eax
jne 0x1eea
callq 0x1dad
pushq $0x1
popq %rax
popq %rcx
retq
callq 0x1f8b
jmp 0x1ede
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x1f08
cmpl $0x23, %eax
je 0x1f1b
cmpl $0x5b, %eax
jne 0x1f2e
callq 0x21ee
jmp 0x1ede
callq 0x1582
leaq 0x2d35c(%rip), %rdi     # 0x2f270
callq 0x20b4
jmp 0x1ede
callq 0x23f7
jmp 0x1ede
leaq 0x22ce(%rip), %rdi      # 0x41f7
callq 0x12ef
leaq 0x22d9(%rip), %rdi      # 0x420e
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newString
struct object  *newString(char *text)
{
  int             size,
                  i;
  struct byteObject *newObj;

  size = strlen(text);
  newObj = binaryAlloc(size);
  for(i = 0; i < size; i++)
    newObj->bytes[i] = text[i];
  newObj->class = lookupGlobal("String", 0);
  return (struct object *) newObj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1090
movq %rax, %r15
movl %r15d, %edi
callq 0x12d6
movq %rax, %r14
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x1f70
movb (%rbx,%rax), %cl
movb %cl, 0x10(%r14,%rax)
incq %rax
jmp 0x1f5e
leaq 0x21d9(%rip), %rdi      # 0x4150
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseString
int parseString(void)
{
  char           *q;

  p++;
  for(q = tokenBuffer; *p && *p != '\'';)
    *q++ = *p++;
  if(*p != '\'')
    return parseError("missing end of string");
  p++;
  skipSpaces();
  *q = '\0';
  genInstruction(PushLiteral, addLiteral(newString(tokenBuffer)));
  return 1;
}

// Assembly:
pushq %rbx
movq 0x61bd(%rip), %rax      # 0x8150
leaq 0x1(%rax), %rcx
movq %rcx, 0x61b2(%rip)      # 0x8150
addq $0x2, %rax
leaq 0x2d2c7(%rip), %rbx     # 0x2f270
movzbl -0x1(%rax), %ecx
cmpl $0x27, %ecx
je 0x1fd1
testl %ecx, %ecx
je 0x2003
leaq -0x1(%rax), %rcx
incq %rcx
movq %rcx, 0x618c(%rip)      # 0x8150
movb -0x1(%rax), %cl
movb %cl, (%rbx)
incq %rbx
incq %rax
jmp 0x1fa9
movq %rax, 0x6178(%rip)      # 0x8150
callq 0x149d
movb $0x0, (%rbx)
leaq 0x2d289(%rip), %rdi     # 0x2f270
callq 0x1f3a
movq %rax, %rdi
callq 0x1984
pushq $0x4
popq %rdi
movl %eax, %esi
callq 0x191c
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x218c(%rip), %rdi      # 0x4196
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: lookupInstance
int lookupInstance(struct object *class, char *text, int *low)
{
  struct object  *var;
  int             size,
                  i;

  /*
     first check superclasses 
   */
  var = class->data[parentClassInClass];
  if(var && var != nilObject)
  {
    size = lookupInstance(var, text, low);
    if(size >= 0)
      return size;
  }
  else
  {                             /* no superclass */
    *low = 0;
  }

  /*
     Check our own list of variables 
   */
  var = class->data[variablesInClass];
  if(var && var != nilObject)
  {
    size = SIZE(var);
  }
  else
  {
    size = 0;
  }
  for(i = 0; i < size; i++)
  {
    if(symbolBareCmp
       (text, strlen(text), (char *) bytePtr(var->data[i]),
        (SIZE(var->data[i]))) == 0)
    {
      return (*low);
    }
    *low += 1;
  }
  return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2048
cmpq 0x510d(%rip), %rdi      # 0x7140
je 0x2048
movq %r14, %rsi
movq %rbx, %rdx
callq 0x200f
movl %eax, %ebp
testl %eax, %eax
jns 0x20a3
jmp 0x204b
andl $0x0, (%rbx)
movq 0x30(%r15), %r15
xorl %r12d, %r12d
testq %r15, %r15
je 0x2067
cmpq 0x50e2(%rip), %r15      # 0x7140
je 0x2067
movl (%r15), %r12d
shrl $0x2, %r12d
xorl %r13d, %r13d
pushq $-0x1
popq %rbp
cmpq %r13, %r12
je 0x20a3
movq %r14, %rdi
callq 0x1090
movq 0x10(%r15,%r13,8), %rdx
movl (%rdx), %ecx
addq $0x10, %rdx
shrl $0x2, %ecx
movq %r14, %rdi
movl %eax, %esi
callq 0x1646
movl (%rbx), %ecx
testl %eax, %eax
je 0x20a1
incl %ecx
movl %ecx, (%rbx)
incq %r13
jmp 0x206d
movl %ecx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: nameTerm
int nameTerm(char *name)
{
  int             i;

  /*
     see if temporary 
   */
  for(i = 0; i < tempTop; i++)
  {
    if(strcmp(name, tempBuffer[i]) == 0)
    {
      genInstruction(PushTemporary, i);
      return 1;
    }
  }

  /*
     see if argument 
   */
  for(i = 0; i < argumentTop; i++)
  {
    if(strcmp(name, argumentNames[i]) == 0)
    {
      genInstruction(PushArgument, i);
      return 1;
    }
  }

  /*
     see if super 
   */
  if(strcmp(name, "super") == 0)
  {
    genInstruction(PushArgument, 0);
    superMessage = 1;
    return 1;
  }

  /*
     see if low constant 
   */
  for(i = 0; lowConstants[i]; i++)
  {
    if(strcmp(lowConstants[i], name) == 0)
    {
      genInstruction(PushConstant, 10 + i);
      return 1;
    }
  }

  /*
     see if instance variable 
   */
  if(currentClass)
  {
    int             low;

    i = lookupInstance(currentClass, name, &low);
    if(i >= 0)
    {
      genInstruction(PushInstance, i);
      return 1;
    }
  }

  /*
     see if global 
   */
  {
    struct object  *glob = lookupGlobal(name, 1);

    if(glob)
    {
      genInstruction(PushLiteral, addLiteral(glob));
      return 1;
    }
  }

  return (parseError("unknown identifier"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x38416(%rip), %r15d    # 0x3a4e0
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
leaq 0x37465(%rip), %r12     # 0x39540
cmpq %r14, %r15
je 0x20f9
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x212f
incq %r14
addq $0x8, %r12
jmp 0x20db
movl 0x37430(%rip), %r15d    # 0x39530
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
leaq 0x3732f(%rip), %r12     # 0x39440
cmpq %r14, %r15
je 0x2133
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x216c
incq %r14
addq $0x8, %r12
jmp 0x2111
pushq $0x3
jmp 0x216e
leaq 0x2072(%rip), %rsi      # 0x41ac
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x2187
pushq $0xa
popq %rbp
leaq 0x4f80(%rip), %r14      # 0x70d0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x219b
movq %rbx, %rsi
callq 0x10e0
testl %eax, %eax
je 0x21bc
incl %ebp
addq $0x8, %r14
jmp 0x2150
pushq $0x2
popq %rdi
movl %r14d, %esi
callq 0x191c
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x1889
movl $0x1, 0x3839f(%rip)     # 0x3a538
jmp 0x2177
movq 0x3839e(%rip), %rdi     # 0x3a540
testq %rdi, %rdi
je 0x21c3
leaq 0xc(%rsp), %rdx
movq %rbx, %rsi
callq 0x200f
testl %eax, %eax
js 0x21c3
pushq $0x1
jmp 0x21dd
pushq $0x5
popq %rdi
movl %ebp, %esi
jmp 0x2172
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1390
testq %rax, %rax
je 0x21e2
movq %rax, %rdi
callq 0x1984
pushq $0x4
popq %rdi
movl %eax, %esi
jmp 0x2172
leaq 0x1fc9(%rip), %rdi      # 0x41b2
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseStatement
int parseStatement(void)
{
  if(*p == '^')
  {                             /* return statement */
    p++;
    skipSpaces();
    if(!parseExpression())
      return 0;
    genInstruction(DoSpecial, returnOp);
    return 1;
  }
  /*
     otherwise just an expression 
   */
  if(!parseExpression())
    return 0;
  return 1;
}

// Assembly:
pushq %rax
movq 0x5d8c(%rip), %rax      # 0x8150
cmpb $0x5e, (%rax)
jne 0x23ed
incq %rax
movq %rax, 0x5d7d(%rip)      # 0x8150
callq 0x149d
callq 0x24cf
movl 0x38165(%rip), %esi     # 0x3a548
pushq $0xf
popq %rdi
callq 0x191c
jmp 0x23f2
callq 0x24cf
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseSymbol
int parseSymbol(void)
{
  char           *q;

  p++;
  for(q = tokenBuffer; isIdentifierChar(*p) || (*p == ':');)
    *q++ = *p++;
  *q = '\0';
  skipSpaces();
  genInstruction(PushLiteral, addLiteral(newSymbol(tokenBuffer)));
  return 1;
}

// Assembly:
pushq %rbx
movq 0x5d51(%rip), %rax      # 0x8150
incq %rax
movq %rax, 0x5d47(%rip)      # 0x8150
xorl %ecx, %ecx
leaq 0x2ce5e(%rip), %rbx     # 0x2f270
movb (%rax,%rcx), %dl
cmpb $0x3a, %dl
je 0x2425
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x243e
leaq (%rax,%rcx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x5d1c(%rip)      # 0x8150
movb (%rdx), %dl
movb %dl, (%rcx,%rbx)
incq %rcx
jmp 0x2412
movb $0x0, (%rcx,%rbx)
callq 0x149d
movq %rbx, %rdi
callq 0x1696
movq %rax, %rdi
callq 0x1984
pushq $0x4
popq %rdi
movl %eax, %esi
callq 0x191c
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseChar
int parseChar(void)
{
  struct object  *newObj;

  p++;
  newObj = gcalloc(1);
  newObj->class = lookupGlobal("Char", 0);
  newObj->data[0] = newInteger((int) *p);
  genInstruction(PushLiteral, addLiteral(newObj));
  p++;
  skipSpaces();
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
incq 0x5cdf(%rip)            # 0x8150
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x1289
movq %rax, %r14
leaq 0x1c92(%rip), %rdi      # 0x4117
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%r14)
movq 0x5cb9(%rip), %rax      # 0x8150
movsbq (%rax), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x1984
pushq $0x4
popq %rdi
movl %eax, %esi
callq 0x191c
incq 0x5c90(%rip)            # 0x8150
callq 0x149d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseExpression
int parseExpression(void)
{
  char            nameBuffer[60];

  if(isIdentifierChar(*p))
  {
    readIdentifier();
    if((*p == ':') && (*(p + 1) == '='))
    {
      p++;
      p++;
      skipSpaces();
      strcpy(nameBuffer, tokenBuffer);
      if(!parseExpression())
        return 0;
      return doAssignment(nameBuffer);
    }
    if(!nameTerm(tokenBuffer))
      return 0;
  }
  else
  {
    if(!parseTerm())
    {
      return 0;
    }
  }
  if(!parseKeywordContinuation())
  {
    return 0;
  }
  while(*p == ';')
  {
    p++;
    skipSpaces();
    genInstruction(DoSpecial, Duplicate);
    if(!parseKeywordContinuation())
      return 0;
  }
  return 1;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq 0x5c75(%rip), %rax      # 0x8150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jae 0x24ec
callq 0x1e5f
jmp 0x255b
callq 0x1582
movq 0x5c58(%rip), %rax      # 0x8150
cmpb $0x3a, (%rax)
jne 0x2534
cmpb $0x3d, 0x1(%rax)
jne 0x2534
addq $0x2, %rax
movq %rax, 0x5c42(%rip)      # 0x8150
callq 0x149d
leaq 0x2cd56(%rip), %rsi     # 0x2f270
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1060
callq 0x24cf
movq %rbx, %rdi
callq 0x2b7d
jmp 0x256c
leaq 0x2cd35(%rip), %rdi     # 0x2f270
callq 0x20b4
jmp 0x255b
incq %rax
movq %rax, 0x5c04(%rip)      # 0x8150
callq 0x149d
movl $0xf4, %edi
callq 0x1889
callq 0x2955
movq 0x5be9(%rip), %rax      # 0x8150
cmpb $0x3b, (%rax)
je 0x2542
pushq $0x1
popq %rax
addq $0x40, %rsp
popq %rbx
retq