LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2ad5
movq 0x10(%rsp), %rax
cmpq 0x668b(%rip), %rax      # 0x9130
je 0x2ad5
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2a70
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x2ad3
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2ba6
jmp 0x2ae0
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2b14
movq 0x10(%rsp), %rax
cmpq 0x662e(%rip), %rax      # 0x9130
je 0x2b14
movq 0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x2, %eax
movl %eax, 0xc(%rsp)
jmp 0x2b1c
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2b9e
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x1070
movq (%rsp), %rdi
movl %eax, %esi
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rdx
addq $0x10, %rdx
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movl (%rax), %ecx
shrl $0x2, %ecx
callq 0x1a40
cmpl $0x0, %eax
jne 0x2b85
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x2ba6
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2b24
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: parseStatement
int parseStatement(void)
{
  if(*p == '^')
  {                             /* return statement */
    p++;
    skipSpaces();
    if(!parseExpression())
      return 0;
    genInstruction(DoSpecial, returnOp);
    return 1;
  }
  /*
     otherwise just an expression 
   */
  if(!parseExpression())
    return 0;
  return 1;
}

// Assembly:
pushq %rax
movq 0x70e8(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x30a5
movq 0x70d9(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x70ce(%rip)      # 0xa140
callq 0x1630
callq 0x3220
cmpl $0x0, %eax
jne 0x308b
movl $0x0, 0x4(%rsp)
jmp 0x30c1
movl 0x394a7(%rip), %esi     # 0x3c538
movl $0xf, %edi
callq 0x1f80
movl $0x1, 0x4(%rsp)
jmp 0x30c1
callq 0x3220
cmpl $0x0, %eax
jne 0x30b9
movl $0x0, 0x4(%rsp)
jmp 0x30c1
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq 0x7065(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x705a(%rip)      # 0xa140
leaq 0x2e173(%rip), %rax     # 0x31260
movq %rax, 0x10(%rsp)
movq 0x7047(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x3122
movq 0x702b(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x3a, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x312c
jmp 0x3158
movq 0x700d(%rip), %rax      # 0xa140
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x6fff(%rip)      # 0xa140
movb (%rax), %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
jmp 0x30f2
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
callq 0x1630
leaq 0x2e0f4(%rip), %rdi     # 0x31260
callq 0x1b40
movq %rax, %rdi
callq 0x2040
movl %eax, %esi
movl $0x4, %edi
callq 0x1f80
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq 0x6fa8(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6f9d(%rip)      # 0xa140
movl $0x1, %edi
callq 0x1280
movq %rax, (%rsp)
leaq 0x30b6(%rip), %rdi      # 0x626e
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x6f6f(%rip), %rax      # 0xa140
movsbl (%rax), %eax
movslq %eax, %rcx
shlq %rcx
orq $0x1, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rdi
callq 0x2040
movl %eax, %esi
movl $0x4, %edi
callq 0x1f80
movq 0x6f3e(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6f33(%rip)      # 0xa140
callq 0x1630
movl $0x1, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq 0x6f15(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
cmpl $0x0, %eax
je 0x32e0
callq 0x18a0
movq 0x6ef8(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x32c0
movq 0x6ee9(%rip), %rax      # 0xa140
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x32c0
movq 0x6ed9(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6ece(%rip)      # 0xa140
movq 0x6ec7(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6ebc(%rip)      # 0xa140
callq 0x1630
movq %rsp, %rdi
leaq 0x2dfcd(%rip), %rsi     # 0x31260
callq 0x1050
callq 0x3220
cmpl $0x0, %eax
jne 0x32af
movl $0x0, 0x44(%rsp)
jmp 0x335f
movq %rsp, %rdi
callq 0x3c70
movl %eax, 0x44(%rsp)
jmp 0x335f
leaq 0x2df99(%rip), %rdi     # 0x31260
callq 0x2bb0
cmpl $0x0, %eax
jne 0x32de
movl $0x0, 0x44(%rsp)
jmp 0x335f
jmp 0x32f6
callq 0x2750
cmpl $0x0, %eax
jne 0x32f4
movl $0x0, 0x44(%rsp)
jmp 0x335f
jmp 0x32f6
callq 0x38f0
cmpl $0x0, %eax
jne 0x330a
movl $0x0, 0x44(%rsp)
jmp 0x335f
jmp 0x330c
movq 0x6e2d(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x3357
movq 0x6e1e(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6e13(%rip)      # 0xa140
callq 0x1630
movl $0xf, %edi
movl $0x4, %esi
callq 0x1f80
callq 0x38f0
cmpl $0x0, %eax
jne 0x3355
movl $0x0, 0x44(%rsp)
jmp 0x335f
jmp 0x330c
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq 0x6dc5(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
cmpl $0x0, %eax
je 0x3495
movq 0x6dad(%rip), %rax      # 0xa140
movq %rax, 0x8(%rsp)
callq 0x18a0
cmpl $0x0, %eax
je 0x33b3
movq 0x8(%rsp), %rax
movq %rax, 0x6d92(%rip)      # 0xa140
jmp 0x3495
movl $0x0, 0x10(%rsp)
cmpl $0x0, 0x39166(%rip)     # 0x3c528
jne 0x3427
movl $0x0, 0x4(%rsp)
movslq 0x4(%rsp), %rcx
leaq 0x5d08(%rip), %rax      # 0x90e0
cmpq $0x0, (%rax,%rcx,8)
je 0x3425
movslq 0x4(%rsp), %rcx
leaq 0x5cf5(%rip), %rax      # 0x90e0
movq (%rax,%rcx,8), %rsi
leaq 0x2de6a(%rip), %rdi     # 0x31260
callq 0x10c0
cmpl $0x0, %eax
jne 0x3416
movl 0x4(%rsp), %esi
movl $0xa, %edi
callq 0x1f80
movl $0x1, 0x10(%rsp)
jmp 0x3418
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x33cc
jmp 0x3427
cmpl $0x0, 0x10(%rsp)
jne 0x3490
movl $0x8, %edi
movl $0x1, %esi
callq 0x1f80
leaq 0x2de1c(%rip), %rdi     # 0x31260
callq 0x1b40
movq %rax, %rdi
callq 0x2040
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x390cc(%rip)     # 0x3c528
je 0x3478
movl $0xf, %edi
movl $0xb, %esi
callq 0x1f80
movl 0x14(%rsp), %edi
callq 0x1e70
jmp 0x3486
movl 0x14(%rsp), %esi
movl $0x9, %edi
callq 0x1f80
movl $0x0, 0x39098(%rip)     # 0x3c528
jmp 0x3374
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
callq 0x3370
cmpl $0x0, %eax
jne 0x34bb
movl $0x0, 0x64(%rsp)
jmp 0x35fb
jmp 0x34bd
movq 0x6c7c(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x17e0
cmpl $0x0, %eax
je 0x35f3
callq 0x1830
movq %rsp, %rdi
leaq 0x2dd7c(%rip), %rsi     # 0x31260
callq 0x1050
callq 0x2750
cmpl $0x0, %eax
jne 0x3500
movl $0x0, 0x64(%rsp)
jmp 0x35fb
callq 0x3370
cmpl $0x0, %eax
jne 0x3517
movl $0x0, 0x64(%rsp)
jmp 0x35fb
movl $0x0, 0x58(%rsp)
cmpl $0x0, 0x39002(%rip)     # 0x3c528
jne 0x3587
movl $0x0, 0x5c(%rsp)
movslq 0x5c(%rsp), %rcx
leaq 0x5bc4(%rip), %rax      # 0x9100
cmpq $0x0, (%rax,%rcx,8)
je 0x3585
movq %rsp, %rdi
movslq 0x5c(%rsp), %rcx
leaq 0x5bae(%rip), %rax      # 0x9100
movq (%rax,%rcx,8), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3576
movl 0x5c(%rsp), %esi
movl $0xb, %edi
callq 0x1f80
movl $0x1, 0x58(%rsp)
jmp 0x3578
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x3530
jmp 0x3587
cmpl $0x0, 0x58(%rsp)
jne 0x35ee
movq %rsp, %rdi
callq 0x1b40
movq %rax, %rdi
callq 0x2040
movl %eax, 0x60(%rsp)
movl $0x8, %edi
movl $0x2, %esi
callq 0x1f80
cmpl $0x0, 0x38f70(%rip)     # 0x3c528
je 0x35de
movl $0xf, %edi
movl $0xb, %esi
callq 0x1f80
movl 0x60(%rsp), %edi
callq 0x1e70
movl $0x0, 0x38f4c(%rip)     # 0x3c528
jmp 0x35ec
movl 0x60(%rsp), %esi
movl $0x9, %edi
callq 0x1f80
jmp 0x35ee
jmp 0x34bd
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: optimizeBlock
int optimizeBlock(void)
{
  if(*p != '[')
  {
    if(!parseTerm())
      return 0;
    parseError("missing block as optimized block argument");
  }
  else
  {
    p++;
    skipSpaces();
    if(*p == ']')
    {
      genInstruction(PushConstant, 0);
      p++;
      skipSpaces();
      return 1;
    }
    while(1)
    {
      if(!parseStatement())
        return 0;
      if(*p == '.')
        p++, skipSpaces();
      if(*p == ']')
        break;
      genInstruction(DoSpecial, PopTop);
    }
    p++;
    skipSpaces();
    /*
       just leave last expression on stack 
     */
  }
  return 1;
}

// Assembly:
pushq %rax
movq 0x6b28(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x5b, %eax
je 0x3648
callq 0x2750
cmpl $0x0, %eax
jne 0x3637
movl $0x0, 0x4(%rsp)
jmp 0x3718
leaq 0x2d75(%rip), %rdi      # 0x63b3
callq 0x1350
jmp 0x3710
movq 0x6af1(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6ae6(%rip)      # 0xa140
callq 0x1630
movq 0x6ada(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x369b
movl $0x5, %edi
xorl %esi, %esi
callq 0x1f80
movq 0x6abf(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6ab4(%rip)      # 0xa140
callq 0x1630
movl $0x1, 0x4(%rsp)
jmp 0x3718
jmp 0x369d
callq 0x3050
cmpl $0x0, %eax
jne 0x36b1
movl $0x0, 0x4(%rsp)
jmp 0x3718
movq 0x6a88(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x36d7
movq 0x6a79(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6a6e(%rip)      # 0xa140
callq 0x1630
movq 0x6a62(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x36e8
jmp 0x36f9
movl $0xf, %edi
movl $0x5, %esi
callq 0x1f80
jmp 0x369d
movq 0x6a40(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x6a35(%rip)      # 0xa140
callq 0x1630
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl 0x24(%rsp), %esi
movl $0xf, %edi
callq 0x1f80
movl 0x379bb(%rip), %eax     # 0x3b100
movl %eax, 0x10(%rsp)
xorl %edi, %edi
callq 0x1ec0
callq 0x3610
cmpl $0x0, %eax
jne 0x3766
leaq 0x2c7c(%rip), %rdi      # 0x63dd
callq 0x1350
movl $0xf, %edi
movl $0x6, %esi
callq 0x1f80
movl 0x37985(%rip), %eax     # 0x3b100
movl %eax, 0xc(%rsp)
xorl %edi, %edi
callq 0x1ec0
movl 0x10(%rsp), %edi
movl 0x37970(%rip), %esi     # 0x3b100
callq 0x1f10
movq 0x69a4(%rip), %rax      # 0xa140
movq %rax, (%rsp)
movq 0x6999(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
cmpl $0x0, %eax
je 0x37ec
callq 0x18a0
cmpl $0x0, %eax
je 0x37ec
movq 0x18(%rsp), %rsi
leaq 0x2da96(%rip), %rdi     # 0x31260
callq 0x10c0
cmpl $0x0, %eax
jne 0x37ec
callq 0x3610
cmpl $0x0, %eax
jne 0x37ea
leaq 0x2c15(%rip), %rdi      # 0x63fa
callq 0x1350
jmp 0x3805
movq (%rsp), %rax
movq %rax, 0x6949(%rip)      # 0xa140
movl 0x14(%rsp), %esi
movl $0x5, %edi
callq 0x1f80
movl 0xc(%rsp), %edi
movl 0x378f1(%rip), %esi     # 0x3b100
callq 0x1f10
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq 0x38d11(%rip), %rax     # 0x3c540
movq %rax, 0x690a(%rip)      # 0xa140
movl 0x378c4(%rip), %eax     # 0x3b100
movl %eax, 0xc(%rsp)
callq 0x3610
movl 0x10(%rsp), %esi
movl $0xf, %edi
callq 0x1f80
movl 0x378a7(%rip), %eax     # 0x3b100
movl %eax, 0x8(%rsp)
xorl %edi, %edi
callq 0x1ec0
movq 0x68d5(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
cmpl $0x0, %eax
je 0x3882
callq 0x18a0
cmpl $0x0, %eax
jne 0x3894
leaq 0x2b91(%rip), %rdi      # 0x641a
callq 0x1350
movl %eax, 0x14(%rsp)
jmp 0x38e3
callq 0x3610
movl $0xf, %edi
movl $0x5, %esi
callq 0x1f80
movl $0xf, %edi
movl $0x6, %esi
callq 0x1f80
movl 0xc(%rsp), %edi
callq 0x1ec0
movl 0x8(%rsp), %edi
movl 0x37836(%rip), %esi     # 0x3b100
callq 0x1f10
movl $0x5, %edi
xorl %esi, %esi
callq 0x1f80
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x38845(%rip), %eax     # 0x3c4d0
jge 0x3cd3
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x37892(%rip), %rax     # 0x3b530
movq (%rax,%rcx,8), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3cc4
movl 0x4(%rsp), %esi
movl $0x7, %edi
callq 0x1f80
movl $0x1, 0x14(%rsp)
jmp 0x3d26
jmp 0x3cc6
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3c81
cmpq $0x0, 0x38855(%rip)     # 0x3c530
je 0x3d16
movq 0x3884c(%rip), %rdi     # 0x3c530
movq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq 0x2a70
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x3d14
movl 0x4(%rsp), %esi
movl $0x6, %edi
callq 0x1f80
movl $0x1, 0x14(%rsp)
jmp 0x3d26
jmp 0x3d16
leaq 0x2754(%rip), %rdi      # 0x6471
callq 0x1350
movl %eax, 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: 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, 0x387fd(%rip)     # 0x3c538
movq 0x63fe(%rip), %rax      # 0xa140
cmpb $0x0, (%rax)
je 0x3d92
callq 0x3050
cmpl $0x0, %eax
jne 0x3d5b
movl $0x0, 0x4(%rsp)
jmp 0x3da9
movl $0xf, %edi
movl $0x5, %esi
callq 0x1f80
movq 0x63cf(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x3d90
movq 0x63c0(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x63b5(%rip)      # 0xa140
callq 0x1630
jmp 0x3d3b
movl $0xf, %edi
movl $0x1, %esi
callq 0x1f80
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x0, 0x38535(%rip)     # 0x3c4d0
movl $0x0, 0x3852f(%rip)     # 0x3c4d4
movq 0x6194(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x7c, %eax
je 0x3fc1
movl $0x1, 0x4(%rsp)
jmp 0x4056
movq 0x6178(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x616d(%rip)      # 0xa140
callq 0x1630
movq 0x6161(%rip), %rax      # 0xa140
movsbl (%rax), %eax
cmpl $0x7c, %eax
je 0x4037
movq 0x6152(%rip), %rax      # 0xa140
movsbl (%rax), %edi
callq 0x1790
cmpl $0x0, %eax
jne 0x400d
leaq 0x24e4(%rip), %rdi      # 0x64e6
callq 0x1350
movl %eax, 0x4(%rsp)
jmp 0x4056
callq 0x18a0
cmpl $0x0, %eax
je 0x4029
leaq 0x2311(%rip), %rdi      # 0x632f
callq 0x1350
movl %eax, 0x4(%rsp)
jmp 0x4056
leaq 0x2d230(%rip), %rdi     # 0x31260
callq 0x2190
jmp 0x3fd8
movq 0x6102(%rip), %rax      # 0xa140
addq $0x1, %rax
movq %rax, 0x60f7(%rip)      # 0xa140
callq 0x1630
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x3db0
cmpl $0x0, %eax
jne 0x4085
movl $0x0, 0x14(%rsp)
jmp 0x416f
callq 0x3f90
cmpl $0x0, %eax
jne 0x409c
movl $0x0, 0x14(%rsp)
jmp 0x416f
callq 0x3d30
cmpl $0x0, %eax
je 0x4167
callq 0x2090
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x1fc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x27, %ecx
movq %rcx, 0x28(%rax)
movslq 0x383f3(%rip), %rcx     # 0x3c4d4
shlq %rcx
orq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x38438(%rip), %rcx     # 0x3c530
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
leaq 0x5038(%rip), %rdi      # 0x9140
callq 0x28f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, 0x38427(%rip)     # 0x3c548
jne 0x4136
leaq 0x23cc(%rip), %rdi      # 0x64f6
callq 0x28f0
movq %rax, 0x38412(%rip)     # 0x3c548
movq 0x3840b(%rip), %rcx     # 0x3c548
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movslq 0x2d10f(%rip), %rcx     # 0x3125c
shlq %rcx
orq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x1, 0x14(%rsp)
jmp 0x416f
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: BeginCommand
struct object  *BeginCommand(void)
{
  struct object  *bootMethod;

  byteTop = 0;
  litTop = 0;
  argumentTop = 0;
  currentClass = 0;
  tempTop = 0;
  maxTemp = 0;

  if(parseBody())
  {
    printf("parsed begin command ok\n");
    bootMethod = gcalloc(methodSize);
    bootMethod->class = lookupGlobal("Method", 0);
    bootMethod->data[nameInMethod] = newSymbol("boot");
    bootMethod->data[literalsInMethod] = buildLiteralArray();
    bootMethod->data[byteCodesInMethod] = buildByteArray();
    bootMethod->data[stackSizeInMethod] = newInteger(12);
  }
  else
  {
    parseError("building begin method");
  }

  return bootMethod;
}

// Assembly:
pushq %rax
movl $0x0, 0x36f75(%rip)     # 0x3b100
movl $0x0, 0x36f6f(%rip)     # 0x3b104
movl $0x0, 0x37381(%rip)     # 0x3b520
movq $0x0, 0x38386(%rip) # 0x3c530
movl $0x0, 0x3831c(%rip)     # 0x3c4d0
movl $0x0, 0x38316(%rip)     # 0x3c4d4
callq 0x3d30
cmpl $0x0, %eax
je 0x4243
leaq 0x2340(%rip), %rdi      # 0x650f
movb $0x0, %al
callq 0x1080
movl $0x9, %edi
callq 0x1280
movq %rax, (%rsp)
leaq 0x238a(%rip), %rdi      # 0x6575
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x2324(%rip), %rdi      # 0x6528
callq 0x1b40
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x2090
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x1fc0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movl $0x19, %ecx
movq %rcx, 0x28(%rax)
jmp 0x424f
leaq 0x22e3(%rip), %rdi      # 0x652d
callq 0x1350
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: insert
struct object  *insert(struct object *array, LstUInt index, struct object *val)
{
  LstUInt         i,
                  j;
  struct object  *o;

  /*
   * Clone the current object, including class.  Make one
   * extra slot in the Array storage.
   */
  o = gcalloc(SIZE(array) + 1);
  o->class = array->class;

  /*
   * Copy up to the index
   */
  for(i = 0; i < index; ++i)
  {
    o->data[i] = array->data[i];
  }

  /*
   * Put in the new element at this position
   */
  j = i;
  o->data[i++] = val;

  /*
   * Now copy the rest
   */
  for(; j < SIZE(array); ++j)
  {
    o->data[i++] = array->data[j];
  }
  return (o);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %edi
shrl $0x2, %edi
addl $0x1, %edi
callq 0x1280
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x42d3
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0x10(%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 0x42a1
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdx
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rsp)
movl %ecx, %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jae 0x433d
movq 0x20(%rsp), %rax
movl 0x8(%rsp), %ecx
movq 0x10(%rax,%rcx,8), %rdx
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rsp)
movl %ecx, %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x42f8
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: dictionaryInsert
void
dictionaryInsert(struct object *dict, struct object *index,
                 struct object *value)
{
  struct object  *keys = dict->data[0],
    *vals = dict->data[1];
  int             i,
                  lim,
                  res;

  /*
   * Scan the OrderedArray "keys" to find where we fit in
   */
  for(i = 0, lim = SIZE(keys); i < lim; ++i)
  {
    res = symbolCmp(index, keys->data[i]);

    /*
     * We should go in before this node
     */
    if(res < 0)
    {
      dict->data[0] = insert(keys, i, index);
      dict->data[1] = insert(vals, i, value);
      return;
    }
    else if(res > 0)
    {
      continue;
    }
    else
    {
      sysError("dictionary insert:", "duplicate key");
    }
  }

  /*
   * The new element goes at the end
   */
  dict->data[0] = insert(keys, i, index);
  dict->data[1] = insert(vals, i, value);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
shrl $0x2, %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x4437
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
callq 0x1b00
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x4407
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x4260
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x4260
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4475
cmpl $0x0, 0x4(%rsp)
jle 0x4410
jmp 0x4427
leaq 0x212c(%rip), %rdi      # 0x6543
leaq 0x2138(%rip), %rsi      # 0x6556
callq 0x1250
jmp 0x4425
jmp 0x4427
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4395
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x4260
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x4260
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: MethodCommand
void MethodCommand(void)
{
  struct object  *theMethod;

  /*
     read class name 
   */
  readIdentifier();
  currentClass = lookupGlobal(tokenBuffer, 1);
  if(!currentClass)
  {
    sysError("unknown class in Method", tokenBuffer);
  }

  inputMethodText();

  p = inputBuffer;
  skipSpaces();

  theMethod = gcalloc(methodSize);
  theMethod->class = lookupGlobal("Method", 0);

  /*
     fill in method class 
   */
  byteTop = 0;
  litTop = 0;
  argumentTop = 1;

  /*
   * If successful compile, insert into the method dictionary
   */
  if(parseMethod(theMethod))
  {
    dictionaryInsert(currentClass->data[methodsInClass],
                     theMethod->data[nameInMethod], theMethod);
  }
}

// Assembly:
pushq %rax
callq 0x18a0
leaq 0x2cdd3(%rip), %rdi     # 0x31260
movl $0x1, %esi
callq 0x1470
movq %rax, 0x38092(%rip)     # 0x3c530
cmpq $0x0, 0x3808a(%rip)     # 0x3c530
jne 0x44bb
leaq 0x20b5(%rip), %rdi      # 0x6564
leaq 0x2cdaa(%rip), %rsi     # 0x31260
callq 0x1250
callq 0x1540
leaq 0x4c79(%rip), %rax      # 0x9140
movq %rax, 0x5c72(%rip)      # 0xa140
callq 0x1630
movl $0x9, %edi
callq 0x1280
movq %rax, (%rsp)
leaq 0x208d(%rip), %rdi      # 0x6575
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x36bfc(%rip)     # 0x3b100
movl $0x0, 0x36bf6(%rip)     # 0x3b104
movl $0x1, 0x37008(%rip)     # 0x3b520
movq (%rsp), %rdi
callq 0x4060
cmpl $0x0, %eax
je 0x4542
movq 0x38003(%rip), %rax     # 0x3c530
movq 0x20(%rax), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq (%rsp), %rdx
callq 0x4350
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: ClassCommand
void ClassCommand(void)
{
  char           *class,
                 *super,
                 *ivars;

  /*
     Read the class and superclass 
   */
  readIdentifier();
  class = strdup(tokenBuffer);
  readIdentifier();
  super = strdup(tokenBuffer);

  /*
     Stash away the instance variable string 
   */
  skipSpaces();
  ivars = strdup(p);

  /*
     Build the metaclass 
   */
  sprintf(inputBuffer, "RAWCLASS Meta%s Class Meta%s", class, super);
  p = inputBuffer + 9;
  RawClassCommand();

  /*
     Now the instance class 
   */
  sprintf(inputBuffer, "RAWCLASS %s Meta%s %s %s", class, class,
          super, ivars);
  p = inputBuffer + 9;
  RawClassCommand();
  free(class);
  free(super);
  free(ivars);
}

// Assembly:
subq $0x18, %rsp
callq 0x18a0
leaq 0x2cb30(%rip), %rdi     # 0x31260
callq 0x1140
movq %rax, 0x10(%rsp)
callq 0x18a0
leaq 0x2cb1a(%rip), %rdi     # 0x31260
callq 0x1140
movq %rax, 0x8(%rsp)
callq 0x1630
movq 0x59e4(%rip), %rdi      # 0xa140
callq 0x1140
movq %rax, (%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x49ca(%rip), %rdi      # 0x9140
leaq 0x1e4a(%rip), %rsi      # 0x65c7
movb $0x0, %al
callq 0x1110
leaq 0x49b5(%rip), %rax      # 0x9140
addq $0x9, %rax
movq %rax, 0x59aa(%rip)      # 0xa140
callq 0x4550
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
leaq 0x498b(%rip), %rdi      # 0x9140
leaq 0x1e28(%rip), %rsi      # 0x65e4
movb $0x0, %al
callq 0x1110
leaq 0x4976(%rip), %rax      # 0x9140
addq $0x9, %rax
movq %rax, 0x596b(%rip)      # 0xa140
callq 0x4550
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: writeWord
void writeWord(int i, FILE * fp)
{
  if(i < 0)
  {
    sysError("writeWord: negative value", (void *)(INT_PTR)i);
  }
  if(i >= 255)
  {
    fputc(255, fp);
    writeWord(i - 255, fp);
  }
  else
  {
    fputc(i, fp);
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x4825
movslq 0x14(%rsp), %rsi
leaq 0x1ddd(%rip), %rdi      # 0x65fd
callq 0x1250
cmpl $0xff, 0x14(%rsp)
jl 0x4854
movq 0x8(%rsp), %rsi
movl $0xff, %edi
callq 0x10a0
movl 0x14(%rsp), %edi
subl $0xff, %edi
movq 0x8(%rsp), %rsi
callq 0x4800
jmp 0x4862
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x10a0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: symbolTreeInsert
struct object  *symbolTreeInsert(struct object *base, struct object *symNode)
{
  if(base == nilObject)
    return symNode;
  if(symbolCmp(symNode->data[valueInNode], base->data[valueInNode]) < 0)
    base->data[leftInNode] =
      symbolTreeInsert(base->data[leftInNode], symNode);
  else
    base->data[rightInNode] =
      symbolTreeInsert(base->data[rightInNode], symNode);
  return base;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
cmpq 0x4617(%rip), %rax      # 0x9130
jne 0x4b26
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4b89
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x1b00
cmpl $0x0, %eax
jge 0x4b61
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rsp), %rsi
callq 0x4b00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4b7f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rsp), %rsi
callq 0x4b00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%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: fixSymbols
struct object  *fixSymbols(void)
{
  struct object  *t;
  LstUInt         i;

  t = newTree();
  for(i = 0; i < symbolTop; i++)
    t->data[0] = symbolTreeInsert(t->data[0],
                                  newNode(oldSymbols[i], nilObject,
                                          nilObject));
  return t;
}

// Assembly:
subq $0x18, %rsp
callq 0x1d50
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c6f0(%rip), %eax     # 0x312b0
jae 0x4c18
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x2c6e4(%rip), %rax     # 0x312c0
movq (%rax,%rcx,8), %rdi
movq 0x4549(%rip), %rsi      # 0x9130
movq 0x4542(%rip), %rdx      # 0x9130
callq 0x1ce0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x4b00
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4bb6
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: fixGlobals
void fixGlobals(void)
{
  struct object  *t;
  int             i;

  t = globalValues;
  t->class = lookupGlobal("Dictionary", 0);
  t->data[0] = newOrderedArray();
  t->data[1] = newArray(0);

  /*
   * Insert each class name as a reference to the class
   * object itself.
   */
  for(i = 0; i < globalTop; i++)
  {
    if(strncmp(globalNames[i], "Meta", 4) == 0)
    {
      continue;
    }
    dictionaryInsert(t, newSymbol(globalNames[i]), globals[i]);
  }

  /*
   * Insert this object itself under the name "Smalltalk"
   */
  dictionaryInsert(t, newSymbol("Smalltalk"), t);
}

// Assembly:
subq $0x28, %rsp
movq 0x378e5(%rip), %rax     # 0x3c520
movq %rax, 0x20(%rsp)
leaq 0x158d(%rip), %rdi      # 0x61d4
xorl %esi, %esi
callq 0x1470
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x1dd0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
xorl %edi, %edi
callq 0x1e00
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x54b8(%rip), %eax      # 0xa148
jge 0x4d03
movslq 0x1c(%rsp), %rcx
leaq 0x54b2(%rip), %rax      # 0xa150
movq (%rax,%rcx,8), %rdi
leaq 0x19c2(%rip), %rsi      # 0x666b
movl $0x4, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x4cba
jmp 0x4cf6
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x5480(%rip), %rax      # 0xa150
movq (%rax,%rcx,8), %rdi
callq 0x1b40
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movslq 0x1c(%rsp), %rcx
leaq 0x18ce3(%rip), %rax     # 0x1d9d0
movq (%rax,%rcx,8), %rdx
callq 0x4350
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4c86
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x195c(%rip), %rdi      # 0x6670
callq 0x1b40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x4350
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: checkGlobals
void checkGlobals(void)
{
  int             i;
  struct object  *o;

  for(i = 0; i < globalTop; i++)
  {
    o = globals[i];
    if(!o->class)
    {
      sysError("Never defined", globalNames[i]);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x5402(%rip), %eax      # 0xa148
jge 0x4d94
movslq 0x14(%rsp), %rcx
leaq 0x18c7c(%rip), %rax     # 0x1d9d0
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4d85
movslq 0x14(%rsp), %rcx
leaq 0x53db(%rip), %rax      # 0xa150
movq (%rax,%rcx,8), %rsi
leaq 0x18fa(%rip), %rdi      # 0x667a
callq 0x1250
jmp 0x4d87
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4d3c
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: call_zopen64
voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc, const void*filename, int mode) {
    if (pfilefunc->zfile_func64.zopen64_file != NULL)
        return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
    else
    {
        return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd2cb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0xd2e8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: call_zseek64
long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin) {
    if (pfilefunc->zfile_func64.zseek64_file != NULL)
        return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
    else
    {
        uLong offsetTruncated = (uLong)offset;
        if (offsetTruncated != offset)
            return -1;
        else
            return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd345
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0xd382
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xd361
movq $-0x1, -0x8(%rbp)
jmp 0xd382
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: call_ztell64
ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc, voidpf filestream) {
    if (pfilefunc->zfile_func64.zseek64_file != NULL)
        return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
    else
    {
        uLong tell_uLong = (uLong)(*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
        if ((tell_uLong) == MAXU32)
            return (ZPOS64_T)-1;
        else
            return tell_uLong;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd3c7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0xd3fe
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x20(%rbp)
jne 0xd3f6
movq $-0x1, -0x8(%rbp)
jmp 0xd3fe
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: fill_zlib_filefunc64_32_def_from_filefunc32
void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32, const zlib_filefunc_def* p_filefunc32) {
    p_filefunc64_32->zfile_func64.zopen64_file = NULL;
    p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
    p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
    p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
    p_filefunc64_32->zfile_func64.ztell64_file = NULL;
    p_filefunc64_32->zfile_func64.zseek64_file = NULL;
    p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
    p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
    p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
    p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: fill_fopen_filefunc
void fill_fopen_filefunc(zlib_filefunc_def* pzlib_filefunc_def) {
    pzlib_filefunc_def->zopen_file = fopen_file_func;
    pzlib_filefunc_def->zread_file = fread_file_func;
    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
    pzlib_filefunc_def->ztell_file = ftell_file_func;
    pzlib_filefunc_def->zseek_file = fseek_file_func;
    pzlib_filefunc_def->zclose_file = fclose_file_func;
    pzlib_filefunc_def->zerror_file = ferror_file_func;
    pzlib_filefunc_def->opaque = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x6d(%rip), %rcx        # 0xd540
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0xff(%rip), %rcx        # 0xd5e0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x130(%rip), %rcx       # 0xd620
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x161(%rip), %rcx       # 0xd660
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0x182(%rip), %rcx       # 0xd690
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq 0x213(%rip), %rcx       # 0xd730
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq 0x234(%rip), %rcx       # 0xd760
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: fopen_file_func
static voidpf ZCALLBACK fopen_file_func(voidpf opaque, const char* filename, int mode) {
    FILE* file = NULL;
    const char* mode_fopen = NULL;
    (void)opaque;
    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
        mode_fopen = "rb";
    else
    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
        mode_fopen = "r+b";
    else
    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
        mode_fopen = "wb";

    if ((filename!=NULL) && (mode_fopen != NULL))
        file = fopen(filename, mode_fopen);
    return file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xd57b
leaq 0x58a8b(%rip), %rax     # 0x66000
movq %rax, -0x28(%rbp)
jmp 0xd5ad
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd593
leaq 0x58a76(%rip), %rax     # 0x66003
movq %rax, -0x28(%rbp)
jmp 0xd5ab
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd5a9
leaq 0x58a62(%rip), %rax     # 0x66007
movq %rax, -0x28(%rbp)
jmp 0xd5ab
jmp 0xd5ad
cmpq $0x0, -0x10(%rbp)
je 0xd5cc
cmpq $0x0, -0x28(%rbp)
je 0xd5cc
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xce70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)