LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x6d7c(%rip), %r14      # 0x8150
cmpq %r14, 0x7d75(%rip)      # 0x9150
je 0x13f9
leaq 0x6d6c(%rip), %r14      # 0x8150
movsbl (%r14), %edi
incq %r14
callq 0x1040
cmpq 0x7d59(%rip), %r14      # 0x9150
jne 0x13e4
leaq 0x3c69(%rip), %rdi      # 0x5069
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10a0
movb (%r14), %al
testb %al, %al
je 0x1426
incq %r14
movsbl %al, %edi
callq 0x1040
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x1414
movl $0xa, %edi
callq 0x1040
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0x1470
movslq 0x7d09(%rip), %rcx      # 0x9158
leaq 0x7d0a(%rip), %rdx      # 0x9160
movq %rax, (%rdx,%rcx,8)
leaq 0x1b57f(%rip), %rax     # 0x1c9e0
movq %rbx, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x7cea(%rip)      # 0x9158
popq %rbx
retq
leaq 0x3bc9(%rip), %rdi      # 0x5040
leaq 0x3bd5(%rip), %rsi      # 0x5053
leaq 0x3be9(%rip), %rdx      # 0x506e
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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
movslq 0x7cae(%rip), %r14      # 0x9158
testq %r14, %r14
jle 0x14d6
shlq $0x3, %r14
xorl %r15d, %r15d
leaq 0x7ca3(%rip), %r12      # 0x9160
movq (%r15,%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x14de
addq $0x8, %r15
cmpq %r15, %r14
jne 0x14bd
testl %ebp, %ebp
je 0x14f2
xorl %eax, %eax
jmp 0x14e9
leaq 0x1b4fb(%rip), %rax     # 0x1c9e0
movq (%r15,%rax), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b47(%rip), %rdi      # 0x5040
leaq 0x3b84(%rip), %rsi      # 0x5084
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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, %eax
cmpl $0xd, %eax
jne 0x152d
movq 0x2ed3a(%rip), %rdi     # 0x30260
callq 0x10b0
jmp 0x151a
cmpl $0xa, %eax
jne 0x1538
incl 0x2ed30(%rip)           # 0x30268
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ed27(%rip), %eax     # 0x30268
movl %eax, 0x2ed25(%rip)     # 0x3026c
leaq 0x6c02(%rip), %rax      # 0x8150
movq %rax, 0x7bfb(%rip)      # 0x9150
callq 0x1514
cmpb $0xa, %al
je 0x1574
movq 0x7beb(%rip), %rcx      # 0x9150
leaq 0x1(%rcx), %rdx
movq %rdx, 0x7be0(%rip)      # 0x9150
movb %al, (%rcx)
jmp 0x1555
movq 0x7bd5(%rip), %rax      # 0x9150
leaq 0x1(%rax), %rcx
movq %rcx, 0x7bca(%rip)      # 0x9150
movb $0xa, (%rax)
callq 0x1514
cmpb $0x21, %al
jne 0x155e
callq 0x1514
cmpb $0xa, %al
je 0x15b2
movq 0x7bae(%rip), %rcx      # 0x9150
leaq 0x1(%rcx), %rdx
movq %rdx, 0x7ba3(%rip)      # 0x9150
movb $0x21, (%rcx)
jmp 0x155e
movq 0x7b97(%rip), %rax      # 0x9150
movb $0x0, (%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movabsq $0x100002600, %rax      # imm = 0x100002600
movq 0x7b80(%rip), %rdx      # 0x9150
leaq 0x1(%rdx), %rcx
movzbl (%rdx), %esi
cmpq $0x22, %rsi
ja 0x1619
btq %rsi, %rax
jae 0x15f2
incq %rdx
movq %rdx, 0x7b63(%rip)      # 0x9150
incq %rcx
jmp 0x15d4
cmpq $0x22, %rsi
jne 0x1619
movq %rcx, 0x7b51(%rip)      # 0x9150
movzbl (%rcx), %edx
cmpl $0x22, %edx
je 0x1610
incq %rcx
testl %edx, %edx
jne 0x15f8
jmp 0x161b
incq 0x7b39(%rip)            # 0x9150
jmp 0x15c9
popq %rax
retq
leaq 0x3a71(%rip), %rdi      # 0x5093
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/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 0x7ae1(%rip), %rbx      # 0x9150
leaq 0x1(%rbx), %rax
movq %rax, 0x7ad6(%rip)      # 0x9150
movb (%rbx), %al
movb %al, 0x2ebee(%rip)      # 0x30270
movsbl 0x1(%rbx), %edi
callq 0x1647
testl %eax, %eax
je 0x16ac
leaq 0x2(%rbx), %rax
movq %rax, 0x7ab6(%rip)      # 0x9150
movb 0x1(%rbx), %al
movb %al, 0x2ebce(%rip)      # 0x30271
movb $0x0, 0x2ebc8(%rip)     # 0x30272
jmp 0x16b3
movb $0x0, 0x2ebbe(%rip)     # 0x30271
popq %rbx
jmp 0x15be
// File: /workspace/github_c_makefile_star2_O1/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 0x7a8f(%rip), %rax      # 0x9150
movb (%rax), %cl
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0x16df
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x16df
leaq 0x2eb93(%rip), %rcx     # 0x30270
jmp 0x1714
incq %rax
leaq 0x2eb87(%rip), %rcx     # 0x30270
movq %rax, 0x7a60(%rip)      # 0x9150
movb -0x1(%rax), %dl
movb %dl, (%rcx)
incq %rcx
movb (%rax), %dl
leal -0x3a(%rdx), %esi
incq %rax
cmpb $-0xb, %sil
ja 0x16e9
andb $-0x21, %dl
addb $-0x5b, %dl
cmpb $-0x1b, %dl
ja 0x16e9
decq %rax
movb $0x0, (%rcx)
xorl %ebx, %ebx
cmpb $0x3a, (%rax)
jne 0x1732
movw $0x3a, (%rcx)
incq %rax
movq %rax, 0x7a23(%rip)      # 0x9150
movl $0x1, %ebx
callq 0x15be
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq 0x7a0a(%rip), %rax      # 0x9150
movb (%rax), %bl
cmpb $0x2d, %bl
jne 0x1757
incq %rax
movq %rax, 0x79f9(%rip)      # 0x9150
movq 0x79f2(%rip), %rax      # 0x9150
leaq 0x1(%rax), %rcx
movq %rcx, 0x79e7(%rip)      # 0x9150
movsbl (%rax), %r14d
addl $-0x30, %r14d
movb 0x1(%rax), %cl
addb $-0x3a, %cl
cmpb $-0xa, %cl
jb 0x17a4
addq $0x2, %rax
leal (%r14,%r14,4), %ecx
movq %rax, 0x79c5(%rip)      # 0x9150
movsbl -0x1(%rax), %edx
leal (%rdx,%rcx,2), %r14d
addl $-0x30, %r14d
movb (%rax), %cl
addb $-0x3a, %cl
incq %rax
cmpb $-0xb, %cl
ja 0x1780
callq 0x15be
movl %r14d, %eax
negl %eax
cmpb $0x2d, %bl
cmovnel %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x2ea82(%rip), %r15d    # 0x302c0
testq %r15, %r15
je 0x1891
movq %rbx, %rdi
callq 0x1090
xorl %ecx, %ecx
leaq 0x2ea7c(%rip), %rdx     # 0x302d0
movq (%rdx,%rcx,8), %r14
movl (%r14), %esi
shrl $0x2, %esi
cmpl %eax, %esi
movl %eax, %edi
cmovll %esi, %edi
testl %edi, %edi
jle 0x1881
movl %edi, %edi
xorl %r8d, %r8d
movb (%rbx,%r8), %r9b
cmpb 0x10(%r14,%r8), %r9b
jne 0x1889
incq %r8
cmpq %r8, %rdi
jne 0x186e
cmpl %eax, %esi
je 0x190c
incq %rcx
cmpq %r15, %rcx
jne 0x1854
movq %rbx, %rdi
callq 0x1090
movq %rax, %r15
leal 0x7(%rax), %edi
andl $-0x8, %edi
callq 0x12bb
movq %rax, %r14
leal 0x2(,%r15,4), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x1090
testq %rax, %rax
je 0x18d8
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, 0x10(%r14,%rcx)
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x18c4
jmp 0x18da
xorl %edx, %edx
movb $0x0, 0x10(%r14,%rdx)
leaq 0x37c1(%rip), %rdi      # 0x50a8
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movl 0x2e9c8(%rip), %eax     # 0x302c0
leal 0x1(%rax), %ecx
movl %ecx, 0x2e9bf(%rip)     # 0x302c0
leaq 0x2e9c8(%rip), %rcx     # 0x302d0
movq %r14, (%rcx,%rax,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x3, %edi
callq 0x12bb
movq %rax, %r12
leaq 0x374a(%rip), %rdi      # 0x50af
xorl %esi, %esi
callq 0x1496
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_O1/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 %r14
pushq %rbx
pushq %rax
movl $0x2, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x36ed(%rip), %rdi      # 0x50b9
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
xorl %edi, %edi
callq 0x12bb
movq %rax, %r14
leaq 0x3797(%rip), %rdi      # 0x517f
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movq %r14, 0x10(%rbx)
xorl %edi, %edi
callq 0x12bb
movq %rax, %r14
leaq 0x377e(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x12bb
movq %rax, %r14
leaq 0x372d(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
testl %ebx, %ebx
jle 0x1b02
movq 0x66cd(%rip), %rax      # 0x8140
movl %ebx, %ecx
incl %ebx
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %ebx
shlq $0x4, %rbx
movdqa 0x357e(%rip), %xmm1     # 0x5010
xorl %ecx, %ecx
movdqa 0x3584(%rip), %xmm2     # 0x5020
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x3584(%rip), %xmm4     # 0x5030
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x1ae2
movq %rax, 0x10(%r14,%rcx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x1af5
movq %rax, 0x18(%r14,%rcx)
paddq %xmm4, %xmm1
addq $0x10, %rcx
cmpq %rcx, %rbx
jne 0x1aac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b75
movl %edi, %ebx
movzbl %bl, %edi
callq 0x1b0d
shrl $0x8, %ebx
movl %ebx, %edi
popq %rbx
jmp 0x1b0d
leaq 0x34c4(%rip), %rdi      # 0x5040
leaq 0x3554(%rip), %rsi      # 0x50d7
leaq 0x39e8(%rip), %rdx      # 0x5572
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0x1bb2
movslq %edi, %rax
leaq 0x38363(%rip), %rcx     # 0x39f10
movw %si, (%rax,%rcx)
retq
pushq %rax
leaq 0x3486(%rip), %rdi      # 0x5040
leaq 0x3516(%rip), %rsi      # 0x50d7
leaq 0x39aa(%rip), %rdx      # 0x5572
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl 0x3850c(%rip), %r14d    # 0x3a110
leal 0x7(%r14), %edi
andl $-0x8, %edi
callq 0x12bb
movq %rax, %rbx
leal 0x2(,%r14,4), %eax
movl %eax, (%rbx)
movl 0x384ed(%rip), %edx     # 0x3a110
testq %rdx, %rdx
je 0x1c3b
movq %rbx, %rdi
addq $0x10, %rdi
leaq 0x382da(%rip), %rsi     # 0x39f10
callq 0x10f0
leaq 0x34a3(%rip), %rdi      # 0x50e5
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x384b6(%rip), %eax     # 0x3a114
leal 0x1(%rax), %ecx
movl %ecx, 0x384ad(%rip)     # 0x3a114
leaq 0x384b2(%rip), %rdx     # 0x3a120
movq %rdi, (%rdx,%rax,8)
cmpl $0x64, %ecx
jae 0x1c78
retq
pushq %rax
leaq 0x33c0(%rip), %rdi      # 0x5040
leaq 0x3468(%rip), %rsi      # 0x50ef
leaq 0x38e4(%rip), %rdx      # 0x5572
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl 0x3846e(%rip), %edi     # 0x3a114
testl %edi, %edi
je 0x1ce8
callq 0x12bb
movq %rax, %rbx
leaq 0x34cd(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movl 0x3844a(%rip), %edx     # 0x3a114
testq %rdx, %rdx
je 0x1cef
movq %rbx, %rdi
addq $0x10, %rdi
shlq $0x3, %rdx
leaq 0x3843f(%rip), %rsi     # 0x3a120
callq 0x10f0
jmp 0x1cef
movq 0x6451(%rip), %rbx      # 0x8140
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d1c
movslq 0x3882a(%rip), %rcx     # 0x3a530
leal 0x1(%rcx), %edx
movl %edx, 0x38821(%rip)     # 0x3a530
leaq 0x3872a(%rip), %rdx     # 0x3a440
movq %rax, (%rdx,%rcx,8)
popq %rax
retq
leaq 0x331d(%rip), %rdi      # 0x5040
leaq 0x33d7(%rip), %rsi      # 0x5101
leaq 0x33df(%rip), %rdx      # 0x5110
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0x1d78
movslq 0x3978c(%rip), %rdx     # 0x3b4e0
leal 0x1(%rdx), %ecx
movl %ecx, 0x39783(%rip)     # 0x3b4e0
leaq 0x387dc(%rip), %rsi     # 0x3a540
movq %rax, (%rsi,%rdx,8)
cmpl 0x39776(%rip), %edx     # 0x3b4e4
jl 0x1d76
movl %ecx, 0x3976e(%rip)     # 0x3b4e4
popq %rax
retq
leaq 0x32c1(%rip), %rdi      # 0x5040
leaq 0x337b(%rip), %rsi      # 0x5101
leaq 0x3390(%rip), %rdx      # 0x511d
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0x173b
cmpl $0x9, %eax
ja 0x21b6
movl $0x5, %edi
jmp 0x21ca
cltq
leaq 0x1(,%rax,2), %rdi
callq 0x1c58
movl $0x4, %edi
movl %eax, %esi
callq 0x1bd9
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x392e3(%rip) # 0x3b550
movl $0x0, 0x392c1(%rip)     # 0x3b538
movq 0x6ed2(%rip), %rcx      # 0x9150
movzbl (%rcx), %eax
cmpl $0x24, %eax
je 0x22c8
cmpl $0x3c, %eax
je 0x22c1
cmpl $0x28, %eax
jne 0x22cf
incq %rcx
movq %rcx, 0x6eb6(%rip)      # 0x9150
callq 0x15be
callq 0x2939
movq 0x6ea5(%rip), %rax      # 0x9150
cmpb $0x29, (%rax)
jne 0x232c
incq %rax
movq %rax, 0x6e96(%rip)      # 0x9150
callq 0x15be
jmp 0x22e6
callq 0x21d8
jmp 0x22e6
callq 0x28d4
jmp 0x22e6
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x22e1
cmpl $0x27, %eax
je 0x22ed
cmpl $0x2d, %eax
jne 0x22f4
callq 0x21a4
movl $0x1, %eax
popq %rcx
retq
callq 0x23a6
jmp 0x22e6
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x2312
cmpl $0x23, %eax
je 0x2325
cmpl $0x5b, %eax
jne 0x2338
callq 0x263d
jmp 0x22e6
callq 0x16b9
leaq 0x2df52(%rip), %rdi     # 0x30270
callq 0x24ed
jmp 0x22e6
callq 0x2847
jmp 0x22e6
leaq 0x2f00(%rip), %rdi      # 0x5233
callq 0x13c6
leaq 0x2f0b(%rip), %rdi      # 0x524a
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/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
leal 0x7(%rax), %edi
andl $-0x8, %edi
callq 0x12bb
movq %rax, %r14
leal 0x2(,%r15,4), %eax
movl %eax, (%r14)
testl %r15d, %r15d
jle 0x238b
movq %r14, %rdi
addq $0x10, %rdi
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq %rbx, %rsi
movq %r15, %rdx
callq 0x10f0
leaq 0x2dfa(%rip), %rdi      # 0x518c
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6da2(%rip), %rax      # 0x9150
leaq 0x1(%rax), %rcx
movq %rcx, 0x6d97(%rip)      # 0x9150
addq $0x2, %rax
leaq 0x2deac(%rip), %rbx     # 0x30270
movzbl -0x1(%rax), %ecx
cmpl $0x27, %ecx
je 0x23ec
testl %ecx, %ecx
je 0x2422
leaq -0x1(%rax), %rcx
incq %rcx
movq %rcx, 0x6d71(%rip)      # 0x9150
movb -0x1(%rax), %cl
movb %cl, (%rbx)
incq %rbx
incq %rax
jmp 0x23c4
movq %rax, 0x6d5d(%rip)      # 0x9150
callq 0x15be
movb $0x0, (%rbx)
leaq 0x2de6e(%rip), %rdi     # 0x30270
callq 0x2344
movq %rax, %rdi
callq 0x1c58
movl $0x4, %edi
movl %eax, %esi
callq 0x1bd9
movl $0x1, %eax
popq %rbx
retq
leaq 0x2da9(%rip), %rdi      # 0x51d2
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/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 0x2467
cmpq 0x5cee(%rip), %rdi      # 0x8140
je 0x2467
movq %r14, %rsi
movq %rbx, %rdx
callq 0x242e
movl %eax, %ebp
testl %eax, %eax
jns 0x24dc
jmp 0x246d
movl $0x0, (%rbx)
movq 0x30(%r15), %r15
xorl %eax, %eax
testq %r15, %r15
je 0x2487
cmpq 0x5cc1(%rip), %r15      # 0x8140
je 0x2487
movl (%r15), %eax
shrl $0x2, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x24dc
movl %eax, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x1090
movq 0x10(%r15,%r13,8), %rdx
movl (%rdx), %ecx
shrl $0x2, %ecx
cmpl %eax, %ecx
movl %eax, %esi
cmovll %ecx, %esi
testl %esi, %esi
jle 0x24ca
movl %esi, %esi
xorl %edi, %edi
movb (%r14,%rdi), %r8b
cmpb 0x10(%rdx,%rdi), %r8b
jne 0x24ce
incq %rdi
cmpq %rdi, %rsi
jne 0x24b7
cmpl %eax, %ecx
je 0x24da
incl (%rbx)
incq %r13
cmpq %r12, %r13
jne 0x2496
jmp 0x24dc
movl (%rbx), %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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x38fe1(%rip), %r15     # 0x3b4e0
testq %r15, %r15
jle 0x252e
leaq 0x38035(%rip), %r12     # 0x3a540
xorl %r14d, %r14d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x25c8
incq %r14
addq $0x8, %r12
cmpq %r14, %r15
jne 0x250e
movslq 0x37ffb(%rip), %r15     # 0x3a530
testq %r15, %r15
jle 0x2560
leaq 0x37eff(%rip), %r12     # 0x3a440
xorl %r14d, %r14d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x25cf
incq %r14
addq $0x8, %r12
cmpq %r14, %r15
jne 0x2544
leaq 0x2c81(%rip), %rsi      # 0x51e8
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x25d6
movq 0x5b56(%rip), %rdi      # 0x80d0
testq %rdi, %rdi
je 0x25a4
movl $0x1, %r14d
leaq 0x5b44(%rip), %r15      # 0x80d0
movq %rbx, %rsi
callq 0x10e0
testl %eax, %eax
je 0x260f
movq (%r15,%r14,8), %rdi
incq %r14
testq %rdi, %rdi
jne 0x258c
movq 0x38f95(%rip), %rdi     # 0x3b540
testq %rdi, %rdi
je 0x25ec
leaq 0x4(%rsp), %rdx
movq %rbx, %rsi
callq 0x242e
testl %eax, %eax
js 0x25ec
movl $0x1, %edi
jmp 0x260b
movl $0x3, %edi
jmp 0x2618
movl $0x2, %edi
jmp 0x2618
movl $0x20, %edi
callq 0x1b0d
movl $0x1, 0x38f4e(%rip)     # 0x3b538
jmp 0x2620
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1496
testq %rax, %rax
je 0x2631
movq %rax, %rdi
callq 0x1c58
movl $0x4, %edi
movl %eax, %esi
jmp 0x261b
addl $0x9, %r14d
movl $0x5, %edi
movl %r14d, %esi
callq 0x1bd9
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2bb6(%rip), %rdi      # 0x51ee
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq 0x6901(%rip), %rax      # 0x9150
leaq 0x1(%rax), %rcx
movq %rcx, 0x68f6(%rip)      # 0x9150
movb 0x1(%rax), %cl
cmpb $0x3a, %cl
je 0x2876
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
jbe 0x2876
leaq 0x2d9fc(%rip), %rcx     # 0x30270
jmp 0x28a5
addq $0x2, %rax
leaq 0x2d9ef(%rip), %rcx     # 0x30270
movq %rax, 0x68c8(%rip)      # 0x9150
movb -0x1(%rax), %dl
movb %dl, (%rcx)
incq %rcx
movb (%rax), %dl
incq %rax
cmpb $0x3a, %dl
je 0x2881
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x1a, %dl
jb 0x2881
movb $0x0, (%rcx)
callq 0x15be
leaq 0x2d9bc(%rip), %rdi     # 0x30270
callq 0x182f
movq %rax, %rdi
callq 0x1c58
movl $0x4, %edi
movl %eax, %esi
callq 0x1bd9
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
incq 0x6874(%rip)            # 0x9150
movl $0x1, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x2863(%rip), %rdi      # 0x5153
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movq 0x684e(%rip), %rax      # 0x9150
movsbq (%rax), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x1c58
movl $0x4, %edi
movl %eax, %esi
callq 0x1bd9
incq 0x6823(%rip)            # 0x9150
callq 0x15be
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x680b(%rip), %rax      # 0x9150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jae 0x2956
callq 0x2261
jmp 0x29c5
callq 0x16b9
movq 0x67ee(%rip), %rax      # 0x9150
cmpb $0x3a, (%rax)
jne 0x299e
cmpb $0x3d, 0x1(%rax)
jne 0x299e
addq $0x2, %rax
movq %rax, 0x67d8(%rip)      # 0x9150
callq 0x15be
leaq 0x2d8ec(%rip), %rsi     # 0x30270
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1060
callq 0x2939
movq %rbx, %rdi
callq 0x3077
jmp 0x29d6
leaq 0x2d8cb(%rip), %rdi     # 0x30270
callq 0x24ed
jmp 0x29c5
incq %rax
movq %rax, 0x679a(%rip)      # 0x9150
callq 0x15be
movl $0xf4, %edi
callq 0x1b0d
callq 0x2e07
movq 0x677f(%rip), %rax      # 0x9150
cmpb $0x3b, (%rax)
je 0x29ac
movl $0x1, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseUnaryContinuation
int parseUnaryContinuation(void)
{
  int             litNumber,
                  done;
  char           *q;

  while(isIdentifierChar(*p))
  {
    q = p;
    if(readIdentifier())
    {
      p = q;                    /* oops, was a keyword */
      break;
    }
    done = 0;
    if(!superMessage)
    {
      int             i;

      for(i = 0; unaryBuiltIns[i]; i++)
        if(strcmp(tokenBuffer, unaryBuiltIns[i]) == 0)
        {
          genInstruction(SendUnary, i);
          done = 1;
        }
    }
    if(!done)
    {
      genInstruction(MarkArguments, 1);
      litNumber = addLiteral(newSymbol(tokenBuffer));

/*printf("unary %s\n", tokenBuffer);*/
      if(superMessage)
      {
        genInstruction(DoSpecial, SendToSuper);
        genByte(litNumber);
      }
      else
        genInstruction(SendMessage, litNumber);
      superMessage = 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x6761(%rip), %r14      # 0x9150
movb (%r14), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2adc
callq 0x16b9
testl %eax, %eax
jne 0x2ad5
leaq 0x2d85e(%rip), %rbx     # 0x30270
leaq 0x56d7(%rip), %r15      # 0x80f0
cmpl $0x0, 0x38b18(%rip)     # 0x3b538
setne %al
movq 0x56c6(%rip), %rsi      # 0x80f0
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x2a68
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
jne 0x2a57
movl $0xa, %edi
movl %r14d, %esi
callq 0x1bd9
movl $0x1, %ebp
movq 0x8(%r15,%r14,8), %rsi
incq %r14
testq %rsi, %rsi
jne 0x2a39
testl %ebp, %ebp
jne 0x2ab6
movl $0x81, %edi
callq 0x1b0d
movq %rbx, %rdi
callq 0x182f
movq %rax, %rdi
callq 0x1c58
movl %eax, %ebp
cmpl $0x0, 0x38aad(%rip)     # 0x3b538
je 0x2aa0
movl $0xfb, %edi
callq 0x1b0d
movl %ebp, %edi
callq 0x1b0d
jmp 0x2aac
movl $0x9, %edi
movl %ebp, %esi
callq 0x1bd9
movl $0x0, 0x38a82(%rip)     # 0x3b538
movq 0x6693(%rip), %r14      # 0x9150
movb (%r14), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x2adc
callq 0x16b9
testl %eax, %eax
je 0x2a19
movq %r14, 0x6674(%rip)      # 0x9150
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseBinaryContinuation
int parseBinaryContinuation(void)
{
  int             messLiteral,
                  i,
                  done;
  char            messbuffer[80];

  if(!parseUnaryContinuation())
    return 0;
  while(isBinary(*p))
  {
    readBinary();

/*printf("binary symbol %s\n", tokenBuffer);*/
    strcpy(messbuffer, tokenBuffer);
    if(!parseTerm())
      return 0;
    if(!parseUnaryContinuation())
      return 0;

    done = 0;
    if(!superMessage)
      for(i = 0; binaryBuiltIns[i]; i++)
        if(strcmp(messbuffer, binaryBuiltIns[i]) == 0)
        {
          genInstruction(SendBinary, i);
          done = 1;
        }

    if(!done)
    {
      messLiteral = addLiteral(newSymbol(messbuffer));
      genInstruction(MarkArguments, 2);
      if(superMessage)
      {
        genInstruction(DoSpecial, SendToSuper);
        genByte(messLiteral);
        superMessage = 0;
      }
      else
        genInstruction(SendMessage, messLiteral);
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
callq 0x29e1
movq 0x664c(%rip), %rax      # 0x9150
movsbl (%rax), %edi
callq 0x1647
testl %eax, %eax
je 0x2bf3
leaq 0x2d755(%rip), %rbx     # 0x30270
movq %rsp, %r14
leaq 0x55eb(%rip), %r12      # 0x8110
callq 0x1667
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1060
callq 0x2261
callq 0x29e1
cmpl $0x0, 0x389f2(%rip)     # 0x3b538
setne %al
movq 0x55c0(%rip), %rsi      # 0x8110
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x2b8e
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x10e0
testl %eax, %eax
jne 0x2b7d
movl $0xb, %edi
movl %r15d, %esi
callq 0x1bd9
movl $0x1, %ebp
movq 0x8(%r12,%r15,8), %rsi
incq %r15
testq %rsi, %rsi
jne 0x2b5f
testl %ebp, %ebp
jne 0x2bdc
movq %r14, %rdi
callq 0x182f
movq %rax, %rdi
callq 0x1c58
movl %eax, %ebp
movl $0x82, %edi
callq 0x1b0d
cmpl $0x0, 0x38987(%rip)     # 0x3b538
je 0x2bd0
movl $0xfb, %edi
callq 0x1b0d
movl %ebp, %edi
callq 0x1b0d
movl $0x0, 0x3896a(%rip)     # 0x3b538
jmp 0x2bdc
movl $0x9, %edi
movl %ebp, %esi
callq 0x1bd9
movq 0x656d(%rip), %rax      # 0x9150
movsbl (%rax), %edi
callq 0x1647
testl %eax, %eax
jne 0x2b25
movl $0x1, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: controlFlow
int controlFlow(int opt1, char *rest, int opt2)
{
  int             save1,
                  save2;
  char           *q;

  genInstruction(DoSpecial, opt1);
  save1 = byteTop;
  genVal(0);
  if(!optimizeBlock())
  {
    parseError("syntax error in control flow");
  }
  genInstruction(DoSpecial, Branch);
  save2 = byteTop;
  genVal(0);
  genValPos(save1, byteTop);
  q = p;
  if(isIdentifierChar(*p) && readIdentifier()
     && (strcmp(tokenBuffer, rest) == 0))
  {
    if(!optimizeBlock())
    {
      parseError("syntax error in control cascade");
    }
  }
  else
  {
    p = q;
    genInstruction(PushConstant, opt2);
  }
  genValPos(save2, byteTop);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %esi
movl $0xf, %edi
callq 0x1bd9
movl 0x37454(%rip), %r15d    # 0x3a110
xorl %edi, %edi
callq 0x1b0d
xorl %edi, %edi
callq 0x1b0d
callq 0x2c05
movl $0xf6, %edi
callq 0x1b0d
movl 0x37431(%rip), %ebp     # 0x3a110
xorl %edi, %edi
callq 0x1b0d
xorl %edi, %edi
callq 0x1b0d
movl 0x3741d(%rip), %esi     # 0x3a110
movl %r15d, %edi
callq 0x1b9b
movq 0x644e(%rip), %r15      # 0x9150
movb (%r15), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2d29
callq 0x16b9
testl %eax, %eax
je 0x2d29
leaq 0x2d553(%rip), %rdi     # 0x30270
movq %r14, %rsi
callq 0x10e0
testl %eax, %eax
je 0x2d59
movq %r15, 0x6420(%rip)      # 0x9150
movl $0x5, %edi
movl %ebx, %esi
callq 0x1bd9
movl 0x373ce(%rip), %esi     # 0x3a110
movl %ebp, %edi
callq 0x1b9b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2c05
jmp 0x2d3c
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: optimizeLoop
int optimizeLoop(int branchInstruction)
{
  int             L1,
                  L2;

  /*
     back up to start of block and try again 
   */
  p = blockbackup;
  L1 = byteTop;
  optimizeBlock();
  genInstruction(DoSpecial, branchInstruction);
  L2 = byteTop;
  genVal(0);
  if(!(isIdentifierChar(*p) && readIdentifier()))
    return parseError("can't get message again in optimized block");
  /*
     now read the body 
   */
  optimizeBlock();
  genInstruction(DoSpecial, PopTop);
  genInstruction(DoSpecial, Branch);
  genVal(L1);
  genValPos(L2, byteTop);
  genInstruction(PushConstant, 0);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movq 0x387e4(%rip), %rax     # 0x3b550
movq %rax, 0x63dd(%rip)      # 0x9150
movl 0x37397(%rip), %ebx     # 0x3a110
callq 0x2c05
movl $0xf, %edi
movl %ebp, %esi
callq 0x1bd9
movl 0x37380(%rip), %ebp     # 0x3a110
xorl %edi, %edi
callq 0x1b0d
xorl %edi, %edi
callq 0x1b0d
movq 0x63ab(%rip), %rax      # 0x9150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2dfb
callq 0x16b9
testl %eax, %eax
je 0x2dfb
callq 0x2c05
movl $0xf5, %edi
callq 0x1b0d
movl $0xf6, %edi
callq 0x1b0d
movl %ebx, %edi
callq 0x1b57
movl 0x37332(%rip), %esi     # 0x3a110
movl %ebp, %edi
callq 0x1b9b
movl $0x50, %edi
callq 0x1b0d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x24a2(%rip), %rdi      # 0x52a4
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: doAssignment
int doAssignment(char *name)
{
  int             i;

  for(i = 0; i < tempTop; i++)
    if(strcmp(name, tempBuffer[i]) == 0)
    {
      genInstruction(AssignTemporary, i);
      return 1;
    }

  if(currentClass)
  {
    int             low;

    i = lookupInstance(currentClass, name, &low);
    if(i >= 0)
    {
      genInstruction(AssignInstance, i);
      return 1;
    }
  }

  return parseError("unknown target of assignment");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x38457(%rip), %r15     # 0x3b4e0
testq %r15, %r15
jle 0x30b4
leaq 0x374ab(%rip), %r12     # 0x3a540
xorl %r14d, %r14d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x30da
incq %r14
addq $0x8, %r12
cmpq %r14, %r15
jne 0x3098
movq 0x38485(%rip), %rdi     # 0x3b540
testq %rdi, %rdi
je 0x30f8
leaq 0x4(%rsp), %rdx
movq %rbx, %rsi
callq 0x242e
testl %eax, %eax
js 0x30f8
movl $0x6, %edi
movl %eax, %esi
jmp 0x30e2
movl $0x7, %edi
movl %r14d, %esi
callq 0x1bd9
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21f8(%rip), %rdi      # 0x52f7
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseBody
int parseBody(void)
{
  returnOp = StackReturn;
  while(*p)
  {
    if(!parseStatement())
      return 0;
    genInstruction(DoSpecial, PopTop);
    if(*p == '.')
    {
      p++;
      skipSpaces();
    }
  }
  genInstruction(DoSpecial, SelfReturn);
  return 1;
}

// Assembly:
pushq %rax
movl $0x2, 0x38439(%rip)     # 0x3b548
movq 0x603a(%rip), %rax      # 0x9150
cmpb $0x0, (%rax)
je 0x3147
callq 0x2808
movl $0xf5, %edi
callq 0x1b0d
movq 0x601f(%rip), %rax      # 0x9150
cmpb $0x2e, (%rax)
jne 0x310f
incq %rax
movq %rax, 0x6010(%rip)      # 0x9150
callq 0x15be
jmp 0x310f
movl $0xf1, %edi
callq 0x1b0d
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseMethodHeader
int parseMethodHeader(struct object *theMethod)
{
  char            messageBuffer[100],
                 *q;
  int             keyflag;

  if(isIdentifierChar(*p))
  {
    if(readIdentifier())
    {                           /* keyword message */
      strcpy(messageBuffer, "");
      keyflag = 1;
      while(keyflag)
      {
        strcat(messageBuffer, tokenBuffer);
        if(isIdentifierChar(*p) && !readIdentifier())
          addArgument(tokenBuffer);
        else
          return parseError("missing argument after keyword");
        q = p;
        if(isIdentifierChar(*p) && readIdentifier())
          keyflag = 1;
        else
        {
          p = q;
          keyflag = 0;
        }
      }
    }
    else
      strcpy(messageBuffer, tokenBuffer); /* unary message */
  }
  else if(isBinary(*p))
  {                             /* binary message */
    readBinary();
    strcpy(messageBuffer, tokenBuffer);
    if(!isIdentifierChar(*p))
      return parseError("missing argument");
    readIdentifier();
    addArgument(tokenBuffer);
  }
  else
    return parseError("ill formed method header");
  theMethod->data[nameInMethod] = newSymbol(messageBuffer);
  printf("Method %s>>%s\n", bytePtr(currentClass->data[nameInClass]),
         messageBuffer);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x5fe3(%rip), %rax      # 0x9150
movb (%rax), %al
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x31c8
movsbl %al, %edi
callq 0x1647
testl %eax, %eax
je 0x3290
callq 0x1667
leaq 0x2d0d8(%rip), %rsi     # 0x30270
movq %rsp, %rdi
callq 0x1060
movq 0x5fa9(%rip), %rax      # 0x9150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x329c
callq 0x16b9
leaq 0x2d0af(%rip), %rdi     # 0x30270
callq 0x1cf4
jmp 0x3244
callq 0x16b9
testl %eax, %eax
je 0x3235
movq %rsp, %r14
movb $0x0, (%r14)
leaq 0x2d091(%rip), %r15     # 0x30270
movq %r14, %rdi
movq %r15, %rsi
callq 0x1120
movq 0x5f5f(%rip), %rax      # 0x9150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x3284
callq 0x16b9
testl %eax, %eax
jne 0x3284
movq %r15, %rdi
callq 0x1cf4
movq 0x5f39(%rip), %r12      # 0x9150
movb (%r12), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x322c
callq 0x16b9
testl %eax, %eax
jne 0x31df
movq %r12, 0x5f1d(%rip)      # 0x9150
jmp 0x3244
leaq 0x2d034(%rip), %rsi     # 0x30270
movq %rsp, %rdi
callq 0x1060
movq %rsp, %r14
movq %r14, %rdi
callq 0x182f
movq %rax, 0x10(%rbx)
movq 0x382e6(%rip), %rax     # 0x3b540
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq 0x20f4(%rip), %rdi      # 0x535d
movq %r14, %rdx
xorl %eax, %eax
callq 0x10a0
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2089(%rip), %rdi      # 0x5314
callq 0x13c6
leaq 0x20ad(%rip), %rdi      # 0x5344
callq 0x13c6
leaq 0x2090(%rip), %rdi      # 0x5333
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseTemporaries
int parseTemporaries(void)
{
  tempTop = 0;
  maxTemp = 0;
  if(*p != '|')
    return 1;
  p++;
  skipSpaces();
  while(*p != '|')
  {
    if(!isIdentifierChar(*p))
      return parseError("need identifier");
    if(readIdentifier())
      return parseError("keyword illegal");
    addTemporary(tokenBuffer);
  }
  p++;
  skipSpaces();
  return 1;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
movl %eax, 0x3822f(%rip)     # 0x3b4e0
movl %eax, 0x3822d(%rip)     # 0x3b4e4
movq 0x5e92(%rip), %rax      # 0x9150
cmpb $0x7c, (%rax)
jne 0x331b
incq %rax
movq %rax, 0x5e83(%rip)      # 0x9150
callq 0x15be
movq 0x5e77(%rip), %rcx      # 0x9150
movb (%rcx), %al
cmpb $0x7c, %al
je 0x330c
leaq 0x2cf8a(%rip), %rbx     # 0x30270
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x3322
callq 0x16b9
testl %eax, %eax
jne 0x332e
movq %rbx, %rdi
callq 0x1d42
movq 0x5e4a(%rip), %rcx      # 0x9150
movb (%rcx), %al
cmpb $0x7c, %al
jne 0x32e6
incq %rcx
movq %rcx, 0x5e3a(%rip)      # 0x9150
callq 0x15be
movl $0x1, %eax
popq %rbx
retq
leaq 0x2043(%rip), %rdi      # 0x536c
callq 0x13c6
leaq 0x1edf(%rip), %rdi      # 0x5214
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseMethod
int parseMethod(struct object *theMethod)
{
  if(!parseMethodHeader(theMethod))
    return 0;
  if(!parseTemporaries())
    return 0;
  if(parseBody())
  {
    theMethod->data[literalsInMethod] = buildLiteralArray();
    theMethod->data[byteCodesInMethod] = buildByteArray();
    theMethod->data[stackSizeInMethod] = newInteger(19);
    theMethod->data[temporarySizeInMethod] = newInteger(maxTemp);
    theMethod->data[classInMethod] = currentClass;
    theMethod->data[textInMethod] = newString(inputBuffer);
    if (!fileNameObj)
      fileNameObj = newString(defaultInputName);
    theMethod->data[fileInMethod] = fileNameObj;
    theMethod->data[lineInMethod] = newInteger(methodLineNo);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3158
callq 0x32a8
callq 0x3104
callq 0x1c9f
movq %rax, 0x20(%rbx)
callq 0x1bf9
movq %rax, 0x18(%rbx)
movq $0x27, 0x28(%rbx)
movslq 0x38176(%rip), %rax     # 0x3b4e4
leaq 0x1(,%rax,2), %rax
movq %rax, 0x30(%rbx)
movq 0x381bf(%rip), %rax     # 0x3b540
movq %rax, 0x38(%rbx)
leaq 0x4dc4(%rip), %rdi      # 0x8150
callq 0x2344
movq %rax, 0x40(%rbx)
cmpq $0x0, 0x381bb(%rip)     # 0x3b558
jne 0x33b2
leaq 0x1fd6(%rip), %rdi      # 0x537c
callq 0x2344
movq %rax, 0x381a6(%rip)     # 0x3b558
movq 0x3819f(%rip), %rax     # 0x3b558
movq %rax, 0x48(%rbx)
movslq 0x2cea8(%rip), %rax     # 0x3026c
leaq 0x1(,%rax,2), %rax
movq %rax, 0x50(%rbx)
movl $0x1, %eax
popq %rbx
retq