LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2169
movq $0x0, -0x8(%rbp)
jmp 0x21bf
jmp 0x216b
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x2187
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2190
jmp 0x21b7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x1, %edx
movsbl (%rax), %esi
callq 0x1db0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x216b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2206
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x220e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2235
jmp 0x228e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2278
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2220
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2245
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22a0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/trie.c
// Function: destroyPostingList
void destroyPostingList(PostingListNode *postingListNode){
    if (!postingListNode)
        return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22b5
jmp 0x22d7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2350
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x10e0
cmpl $0x0, %eax
jne 0x2320
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2357
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x10e0
cmpl $0x0, %eax
je 0x2343
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x234c
movl $0x0, -0x4(%rbp)
jmp 0x2357
jmp 0x234e
jmp 0x22f8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x2397
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x23a0
jmp 0x23cb
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10e0
cmpl $0x0, %eax
jne 0x23bd
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x237f
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x26d8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x268c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x186d0, %rsp          # imm = 0x186D0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x186c8(%rbp)
movl $0x0, -0x186cc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x96a(%rip), %rsi       # 0x307c
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2738
leaq 0xa0b(%rip), %rdi       # 0x3134
callq 0x1140
movl $0x1, %edi
callq 0x1190
jmp 0x273a
leaq -0x186c0(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1869f, %esi          # imm = 0x1869F
callq 0x10d0
cmpq $0x0, %rax
je 0x27a5
movl -0x186cc(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x2794
leaq -0x186c0(%rbp), %rdi
callq 0x1080
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1110
movq %rax, -0x186c8(%rbp)
movq -0x186c8(%rbp), %rdi
leaq -0x186c0(%rbp), %rsi
callq 0x1040
jmp 0x27a5
movl -0x186cc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x186cc(%rbp)
jmp 0x273a
movq -0x18(%rbp), %rdi
callq 0x1060
movq -0x186c8(%rbp), %rax
addq $0x186d0, %rsp          # imm = 0x186D0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xb9b6
jmp 0xb9a0
movl 0x4(%rsp), %eax
subl $0x3, %eax
je 0xb9e3
jmp 0xb9ab
movl 0x4(%rsp), %eax
subl $0x4, %eax
je 0xb9c7
jmp 0xba26
leaq 0x16c1b(%rip), %rax     # 0x225d8
movq %rax, 0x30(%rsp)
jmp 0xba82
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x6c40
movq %rax, 0x30(%rsp)
jmp 0xba82
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
cvttsd2si 0x10(%rsp), %eax
movl %eax, 0x1c(%rsp)
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x20(%rsp), %rax
ucomisd (%rax), %xmm0
jne 0xba24
jp 0xba24
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xbb00
movq %rax, 0x30(%rsp)
jmp 0xba82
jmp 0xba26
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbbc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rsi
callq 0xbd60
cmpl $0x0, %eax
je 0xba5e
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xba82
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xba6e
cmpq $0x0, 0x8(%rsp)
jne 0xba3a
leaq 0x16b5b(%rip), %rax     # 0x225d8
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movslq 0x14(%rsp), %rdi
shlq $0x3, %rdi
addq $0x10, %rdi
callq 0x10e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12ba
leaq 0x4ebd(%rip), %rdi      # 0x616b
leaq 0x4ec4(%rip), %rsi      # 0x6179
callq 0x1250
movl 0x14(%rsp), %ecx
shll $0x2, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
cmpl $0x0, 0x14(%rsp)
jle 0x12f0
movq 0x7e5a(%rip), %rdx      # 0x9130
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rsp)
movslq %ecx, %rcx
movq %rdx, 0x10(%rax,%rcx,8)
jmp 0x12c8
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: binaryAlloc
struct byteObject *binaryAlloc(int size)
{
  int             osize;
  struct byteObject *result;

  osize = (size + BytesPerWord - 1) & (-BytesPerWord);
  result = (struct byteObject *) gcalloc(osize);
  SETSIZE(result, size);
  result->size |= FLAG_BIN;
  return result;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x8, %eax
subl $0x1, %eax
andl $-0x8, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x1280
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
shll $0x2, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x7de0(%rip), %rax      # 0x9140
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x8dcf(%rip), %rax      # 0xa140
je 0x1397
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movsbl (%rax), %esi
leaq 0x4df3(%rip), %rdi      # 0x6181
movb $0x0, %al
callq 0x1080
jmp 0x1365
movq 0x10(%rsp), %rsi
leaq 0x4de1(%rip), %rdi      # 0x6184
movb $0x0, %al
callq 0x1080
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x13d8
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movsbl (%rax), %esi
leaq 0x4db2(%rip), %rdi      # 0x6181
movb $0x0, %al
callq 0x1080
jmp 0x13aa
leaq 0x536b(%rip), %rdi      # 0x674a
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1140
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1426
leaq 0x4d51(%rip), %rdi      # 0x616b
leaq 0x4d68(%rip), %rsi      # 0x6189
callq 0x1250
movq (%rsp), %rdx
movslq 0x8d17(%rip), %rcx      # 0xa148
leaq 0x8d18(%rip), %rax      # 0xa150
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rdx
movslq 0x8d00(%rip), %rcx      # 0xa148
leaq 0x1c581(%rip), %rax     # 0x1d9d0
movq %rdx, (%rax,%rcx,8)
movl 0x8cef(%rip), %eax      # 0xa148
addl $0x1, %eax
movl %eax, 0x8ce6(%rip)      # 0xa148
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x8cbb(%rip), %eax      # 0xa148
jge 0x14d0
movq 0x8(%rsp), %rdi
movslq (%rsp), %rcx
leaq 0x8cb1(%rip), %rax      # 0xa150
movq (%rax,%rcx,8), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x14c3
movslq (%rsp), %rcx
leaq 0x1c518(%rip), %rax     # 0x1d9d0
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x14f1
jmp 0x14c5
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1484
cmpl $0x0, 0x4(%rsp)
jne 0x14e8
movq 0x8(%rsp), %rsi
leaq 0x4cbc(%rip), %rdi      # 0x619f
callq 0x1250
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl $0xd, 0x4(%rsp)
cmpl $0xd, 0x4(%rsp)
jne 0x1522
movq 0x2fd39(%rip), %rdi     # 0x31250
callq 0x1090
movl %eax, 0x4(%rsp)
jmp 0x1509
cmpl $0xa, 0x4(%rsp)
jne 0x1538
movl 0x2fd29(%rip), %eax     # 0x31258
addl $0x1, %eax
movl %eax, 0x2fd20(%rip)     # 0x31258
movl 0x4(%rsp), %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x2fd11(%rip), %eax     # 0x31258
movl %eax, 0x2fd0f(%rip)     # 0x3125c
leaq 0x7bec(%rip), %rax      # 0x9140
movq %rax, 0x8be5(%rip)      # 0xa140
jmp 0x155d
callq 0x1500
movb %al, 0x7(%rsp)
movsbl %al, %eax
cmpl $0xa, %eax
je 0x158b
movb 0x7(%rsp), %cl
movq 0x8bc7(%rip), %rax      # 0xa140
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8bb9(%rip)      # 0xa140
movb %cl, (%rax)
jmp 0x155d
movq 0x8bae(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8ba0(%rip)      # 0xa140
movb $0xa, (%rax)
callq 0x1500
movb %al, 0x7(%rsp)
movsbl %al, %eax
cmpl $0x21, %eax
jne 0x1606
callq 0x1500
movb %al, 0x7(%rsp)
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x15d1
movq 0x8b74(%rip), %rax      # 0xa140
movb $0x0, (%rax)
popq %rax
retq
movq 0x8b68(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8b5a(%rip)      # 0xa140
movb $0x21, (%rax)
movb 0x7(%rsp), %cl
movq 0x8b4c(%rip), %rax      # 0xa140
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8b3e(%rip)      # 0xa140
movb %cl, (%rax)
jmp 0x1621
movb 0x7(%rsp), %cl
movq 0x8b2f(%rip), %rax      # 0xa140
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8b21(%rip)      # 0xa140
movb %cl, (%rax)
jmp 0x155b
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
jmp 0x1633
movq 0x8b06(%rip), %rax      # 0xa140
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, 0x7(%rsp)
je 0x1686
movq 0x8af1(%rip), %rax      # 0xa140
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, 0x7(%rsp)
je 0x1686
movq 0x8adc(%rip), %rax      # 0xa140
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, 0x7(%rsp)
je 0x1686
movq 0x8ac7(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1690
jmp 0x16a4
movq 0x8aa9(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x8a9e(%rip)      # 0xa140
jmp 0x1633
movq 0x8a95(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x1742
movq 0x8a82(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x8a77(%rip)      # 0xa140
movq 0x8a70(%rip), %rax      # 0xa140
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
je 0x16f2
movq 0x8a5b(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x22, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x16fc
jmp 0x1710
movq 0x8a3d(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x8a32(%rip)      # 0xa140
jmp 0x16c9
movq 0x8a29(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x172b
leaq 0x4a88(%rip), %rdi      # 0x61ae
callq 0x1350
movq 0x8a0e(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x8a03(%rip)      # 0xa140
callq 0x1630
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: isIdentifierChar
int isIdentifierChar(char p)
{
  if((p >= 'a') && (p <= 'z'))
    return 1;
  if((p >= 'A') && (p <= 'Z'))
    return 1;
  return 0;
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
cmpl $0x61, %eax
jl 0x17b5
movsbl -0x5(%rsp), %eax
cmpl $0x7a, %eax
jg 0x17b5
movl $0x1, -0x4(%rsp)
jmp 0x17db
movsbl -0x5(%rsp), %eax
cmpl $0x41, %eax
jl 0x17d3
movsbl -0x5(%rsp), %eax
cmpl $0x5a, %eax
jg 0x17d3
movl $0x1, -0x4(%rsp)
jmp 0x17db
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: isBinary
int isBinary(char p)
{
  switch (p)
  {
    case '+':
    case '*':
    case '-':
    case '/':
    case '<':
    case '=':
    case '>':
    case '@':
    case '~':
    case ',':
      return 1;
  }
  return 0;
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
addl $-0x2a, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rsp)
subl $0x54, %eax
ja 0x181a
movq -0x10(%rsp), %rax
leaq 0x47fd(%rip), %rcx      # 0x6004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0x1822
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq 0x8908(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x88fa(%rip)      # 0xa140
movb (%rax), %al
movb %al, 0x2fa12(%rip)      # 0x31260
movq 0x88eb(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x17e0
cmpl $0x0, %eax
je 0x1888
movq 0x88d7(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x88c9(%rip)      # 0xa140
movb (%rax), %al
movb %al, 0x2f9e2(%rip)      # 0x31261
movb $0x0, 0x2f9dc(%rip)     # 0x31262
jmp 0x188f
movb $0x0, 0x2f9d2(%rip)     # 0x31261
callq 0x1630
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
leaq 0x2f9b5(%rip), %rax     # 0x31260
movq %rax, 0x8(%rsp)
movq 0x8889(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
jne 0x18e5
movq 0x886d(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1750
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x18ef
jmp 0x191b
movq 0x884a(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x883c(%rip)      # 0xa140
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x18b0
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x8816(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x196a
movl $0x1, 0x14(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0x3a, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x87e3(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x87d8(%rip)      # 0xa140
jmp 0x1972
movl $0x0, 0x14(%rsp)
callq 0x1630
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x10(%rsp)
movq 0x87ad(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x19b5
movl $0x1, 0x10(%rsp)
movq 0x8796(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x878b(%rip)      # 0xa140
movq 0x8784(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8776(%rip)      # 0xa140
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, 0x14(%rsp)
movq 0x8765(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1750
cmpl $0x0, %eax
je 0x1a10
imull $0xa, 0x14(%rsp), %eax
movq 0x874c(%rip), %rcx      # 0xa140
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x873e(%rip)      # 0xa140
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, 0x14(%rsp)
jmp 0x19d4
callq 0x1630
cmpl $0x0, 0x10(%rsp)
je 0x1a28
xorl %eax, %eax
subl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x1a30
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: symbolBareCmp
int symbolBareCmp(char *left, int leftsize, char *right, int rightsize)
{
  int             minsize = leftsize;
  int             i;

  if(rightsize < minsize)
    minsize = rightsize;
  for(i = 0; i < minsize; i++)
  {
    if(left[i] != right[i])
    {
      if(left[i] < right[i])
      {
        return -1;
      }
      else
      {
        return 1;
      }
    }
  }
  return leftsize - rightsize;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movl %ecx, -0x24(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x28(%rsp), %eax
jge 0x1a6c
movl -0x24(%rsp), %eax
movl %eax, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0x28(%rsp), %eax
jge 0x1ae1
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rsp), %rcx
movslq -0x2c(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1ad2
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rsp), %rcx
movslq -0x2c(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x1ac8
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1aed
movl $0x1, -0x4(%rsp)
jmp 0x1aed
jmp 0x1ad4
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x1a74
movl -0x14(%rsp), %eax
subl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2f755(%rip), %eax     # 0x312b0
jae 0x1bda
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1070
movq 0x10(%rsp), %rdi
movl %eax, %esi
movl 0x24(%rsp), %eax
movl %eax, %ecx
leaq 0x2f73b(%rip), %rax     # 0x312c0
movq (%rax,%rcx,8), %rdx
addq $0x10, %rdx
movl 0x24(%rsp), %eax
movl %eax, %ecx
leaq 0x2f726(%rip), %rax     # 0x312c0
movq (%rax,%rcx,8), %rax
movl (%rax), %ecx
shrl $0x2, %ecx
callq 0x1a40
cmpl $0x0, %eax
jne 0x1bc8
movl 0x24(%rsp), %eax
movl %eax, %ecx
leaq 0x2f706(%rip), %rax     # 0x312c0
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
jmp 0x1c95
jmp 0x1bca
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1b51
movq 0x28(%rsp), %rdi
callq 0x1070
movl %eax, %edi
callq 0x1300
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1070
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1c3e
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movb %dl, 0x10(%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1bf8
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movb $0x0, 0x10(%rax,%rcx)
leaq 0x4570(%rip), %rdi      # 0x61c3
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdx
movl 0x2f63f(%rip), %eax     # 0x312b0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x2f634(%rip)     # 0x312b0
movl %eax, %eax
movl %eax, %ecx
leaq 0x2f639(%rip), %rax     # 0x312c0
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x3, %edi
callq 0x1280
movq %rax, 0x8(%rsp)
leaq 0x44c1(%rip), %rdi      # 0x61ca
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x2, %edi
callq 0x1280
movq %rax, (%rsp)
leaq 0x443e(%rip), %rdi      # 0x61d4
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x1dd0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
xorl %edi, %edi
callq 0x1e00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x1280
movq %rax, 0x8(%rsp)
leaq 0x4484(%rip), %rdi      # 0x62a1
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x1e65
movq 0x72e7(%rip), %rdx      # 0x9130
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1e38
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x1ed6
cmpl $0xffff, 0x4(%rsp)      # imm = 0xFFFF
jle 0x1ee9
leaq 0x4315(%rip), %rdi      # 0x61f2
leaq 0x4867(%rip), %rsi      # 0x674b
callq 0x1250
movl 0x4(%rsp), %edi
andl $0xff, %edi
callq 0x1e70
movl 0x4(%rsp), %edi
sarl $0x8, %edi
callq 0x1e70
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
cmpl $0x0, (%rsp)
jl 0x1f27
cmpl $0xffff, (%rsp)         # imm = 0xFFFF
jle 0x1f3a
leaq 0x42c4(%rip), %rdi      # 0x61f2
leaq 0x4816(%rip), %rsi      # 0x674b
callq 0x1250
movl (%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movslq 0x4(%rsp), %rcx
leaq 0x38fb0(%rip), %rax     # 0x3af00
movb %dl, (%rax,%rcx)
movl (%rsp), %eax
sarl $0x8, %eax
movb %al, %dl
movl 0x4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x38f94(%rip), %rax     # 0x3af00
movb %dl, (%rax,%rcx)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: genInstruction
void genInstruction(int a, int b)
{
  /*
     printf("gen instruction %d %d\n", a, b);
   */
  if(b < 16)
  {
    genByte(a * 16 + b);
  }
  else
  {
    genInstruction(0, a);
    genByte(b);
  }
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
cmpl $0x10, (%rsp)
jge 0x1f9f
movl 0x4(%rsp), %edi
shll $0x4, %edi
addl (%rsp), %edi
callq 0x1e70
jmp 0x1fb2
movl 0x4(%rsp), %esi
xorl %edi, %edi
callq 0x1f80
movl (%rsp), %edi
callq 0x1e70
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl 0x39136(%rip), %edi     # 0x3b100
callq 0x1300
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x3911a(%rip), %eax     # 0x3b100
jae 0x2012
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x38f0b(%rip), %rax     # 0x3af00
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movb %dl, 0x10(%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1fdc
leaq 0x41e7(%rip), %rdi      # 0x6200
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdx
movl 0x390b5(%rip), %eax     # 0x3b104
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x390aa(%rip)     # 0x3b104
movl %eax, %eax
movl %eax, %ecx
leaq 0x390ab(%rip), %rax     # 0x3b110
movq %rdx, (%rax,%rcx,8)
cmpl $0x64, 0x39094(%rip)    # 0x3b104
jb 0x2085
leaq 0x4191(%rip), %rdi      # 0x620a
leaq 0x46cb(%rip), %rsi      # 0x674b
callq 0x1250
movl 0x39079(%rip), %eax     # 0x3b104
subl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
cmpl $0x0, 0x39069(%rip)     # 0x3b104
jne 0x20ab
movq 0x708c(%rip), %rax      # 0x9130
movq %rax, 0x10(%rsp)
jmp 0x211b
movl 0x39053(%rip), %edi     # 0x3b104
callq 0x1280
movq %rax, (%rsp)
leaq 0x41e0(%rip), %rdi      # 0x62a1
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x3901f(%rip), %eax     # 0x3b104
jae 0x2112
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x3901c(%rip), %rax     # 0x3b110
movq (%rax,%rcx,8), %rdx
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x20db
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1140
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2163
leaq 0x40c5(%rip), %rdi      # 0x621c
leaq 0x40cd(%rip), %rsi      # 0x622b
callq 0x1250
movq 0x8(%rsp), %rdx
movl 0x393b2(%rip), %eax     # 0x3b520
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x393a7(%rip)     # 0x3b520
movslq %eax, %rcx
leaq 0x392ad(%rip), %rax     # 0x3b430
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1140
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x21c3
leaq 0x4065(%rip), %rdi      # 0x621c
leaq 0x407a(%rip), %rsi      # 0x6238
callq 0x1250
movq 0x8(%rsp), %rdx
movl 0x3a302(%rip), %eax     # 0x3c4d0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x3a2f7(%rip)     # 0x3c4d0
movslq %eax, %rcx
leaq 0x3934d(%rip), %rax     # 0x3b530
movq %rdx, (%rax,%rcx,8)
movl 0x3a2e3(%rip), %eax     # 0x3c4d0
cmpl 0x3a2e1(%rip), %eax     # 0x3c4d4
jle 0x2201
movl 0x3a2d5(%rip), %eax     # 0x3c4d0
movl %eax, 0x3a2d3(%rip)     # 0x3c4d4
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x1980
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x2618
cmpl $0xa, 0x4(%rsp)
jge 0x2618
movl 0x4(%rsp), %esi
movl $0x5, %edi
callq 0x1f80
jmp 0x2635
movslq 0x4(%rsp), %rdi
shlq %rdi
orq $0x1, %rdi
callq 0x2040
movl %eax, %esi
movl $0x4, %edi
callq 0x1f80
movl $0x1, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parsePrimitive
int parsePrimitive(void)
{
  int             primitiveNumber,
                  argumentCount;

  /*
     skip over the left bracket 
   */
  p++;
  skipSpaces();

  /*
     then read the primitive number 
   */
  if(isDigit(*p))
    primitiveNumber = readInteger();
  else
    return parseError("missing primitive number");

  /*
     then read the arguments 
   */
  for(argumentCount = 0; *p && (*p != '>'); argumentCount++)
    if(!parseTerm())
    {
      return 0;
    }

  /*
     make sure we ended correctly 
   */
  if(*p == '>')
  {
    p++;
    skipSpaces();
  }
  else
    return parseError("missing > at end of primitive");

  /*
     generate instructions 
   */
  genInstruction(DoPrimitive, argumentCount);
  genByte(primitiveNumber);

  /*
     Success 
   */
  return (1);
}

// Assembly:
subq $0x18, %rsp
movq 0x7af5(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x7aea(%rip)      # 0xa140
callq 0x1630
movq 0x7ade(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1750
cmpl $0x0, %eax
je 0x267a
callq 0x1980
movl %eax, 0x10(%rsp)
jmp 0x268f
leaq 0x3c35(%rip), %rdi      # 0x62b6
callq 0x1350
movl %eax, 0x14(%rsp)
jmp 0x2746
movl $0x0, 0xc(%rsp)
movq 0x7aa2(%rip), %rax      # 0xa140
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xb(%rsp)
je 0x26c0
movq 0x7a8d(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x26ca
jmp 0x26ed
callq 0x2750
cmpl $0x0, %eax
jne 0x26de
movl $0x0, 0x14(%rsp)
jmp 0x2746
jmp 0x26e0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2697
movq 0x7a4c(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x2715
movq 0x7a3d(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x7a32(%rip)      # 0xa140
callq 0x1630
jmp 0x2727
leaq 0x3bb3(%rip), %rdi      # 0x62cf
callq 0x1350
movl %eax, 0x14(%rsp)
jmp 0x2746
movl 0xc(%rsp), %esi
movl $0xd, %edi
callq 0x1f80
movl 0x10(%rsp), %edi
callq 0x1e70
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq $0x0, 0x39de4(%rip) # 0x3c540
movl $0x0, 0x39dc2(%rip)     # 0x3c528
movq 0x79d3(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x27eb
movq 0x79c4(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x79b9(%rip)      # 0xa140
callq 0x1630
callq 0x3220
cmpl $0x0, %eax
jne 0x27a3
movl $0x0, 0x4(%rsp)
jmp 0x28df
movq 0x7996(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x27c7
leaq 0x3bb3(%rip), %rdi      # 0x636c
callq 0x1350
movl %eax, 0x4(%rsp)
jmp 0x28df
movq 0x7972(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x7967(%rip)      # 0xa140
callq 0x1630
movl $0x1, 0x4(%rsp)
jmp 0x28df
movq 0x794e(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x2808
callq 0x2640
movl %eax, 0x4(%rsp)
jmp 0x28df
movq 0x7931(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x2825
callq 0x3190
movl %eax, 0x4(%rsp)
jmp 0x28df
movq 0x7914(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1750
cmpl $0x0, %eax
jne 0x2848
movq 0x7900(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2856
callq 0x25f0
movl %eax, 0x4(%rsp)
jmp 0x28df
movq 0x78e3(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x2870
callq 0x2970
movl %eax, 0x4(%rsp)
jmp 0x28df
movq 0x78c9(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
cmpl $0x0, %eax
je 0x289b
callq 0x18a0
leaq 0x2e9d0(%rip), %rdi     # 0x31260
callq 0x2bb0
movl %eax, 0x4(%rsp)
jmp 0x28df
movq 0x789e(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x28b5
callq 0x2db0
movl %eax, 0x4(%rsp)
jmp 0x28df
movq 0x7884(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x28cf
callq 0x30d0
movl %eax, 0x4(%rsp)
jmp 0x28df
leaq 0x3aad(%rip), %rdi      # 0x6383
callq 0x1350
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1070
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x1300
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x294d
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq (%rsp), %rax
movslq 0x8(%rsp), %rcx
movb %dl, 0x10(%rax,%rcx)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x291c
leaq 0x3953(%rip), %rdi      # 0x62a7
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq 0x77c5(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x77ba(%rip)      # 0xa140
leaq 0x2e8d3(%rip), %rax     # 0x31260
movq %rax, 0x8(%rsp)
movq 0x77a7(%rip), %rax      # 0xa140
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x29bb
movq 0x7792(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x27, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x29c5
jmp 0x29f1
movq 0x7774(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x7766(%rip)      # 0xa140
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x2992
movq 0x7748(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x2a12
leaq 0x38e6(%rip), %rdi      # 0x62ed
callq 0x1350
movl %eax, 0x14(%rsp)
jmp 0x2a59
movq 0x7727(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x771c(%rip)      # 0xa140
callq 0x1630
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x2e828(%rip), %rdi     # 0x31260
callq 0x28f0
movq %rax, %rdi
callq 0x2040
movl %eax, %esi
movl $0x4, %edi
callq 0x1f80
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)