LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1cf9
movslq 0x3884d(%rip), %rcx     # 0x3a530
leal 0x1(%rcx), %edx
movl %edx, 0x38844(%rip)     # 0x3a530
leaq 0x3874d(%rip), %rdx     # 0x3a440
movq %rax, (%rdx,%rcx,8)
popq %rax
retq
leaq 0x3340(%rip), %rdi      # 0x5040
leaq 0x33fa(%rip), %rsi      # 0x5101
leaq 0x3402(%rip), %rdx      # 0x5110
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/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 0x1d55
movslq 0x397af(%rip), %rdx     # 0x3b4e0
leal 0x1(%rdx), %ecx
movl %ecx, 0x397a6(%rip)     # 0x3b4e0
leaq 0x387ff(%rip), %rsi     # 0x3a540
movq %rax, (%rsi,%rdx,8)
cmpl 0x39799(%rip), %edx     # 0x3b4e4
jl 0x1d53
movl %ecx, 0x39791(%rip)     # 0x3b4e4
popq %rax
retq
leaq 0x32e4(%rip), %rdi      # 0x5040
leaq 0x339e(%rip), %rsi      # 0x5101
leaq 0x33b3(%rip), %rdx      # 0x511d
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/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 0x1720
cmpl $0x9, %eax
ja 0x2193
movl $0x5, %edi
jmp 0x21a7
cltq
leaq 0x1(,%rax,2), %rdi
callq 0x1c35
movl $0x4, %edi
movl %eax, %esi
callq 0x1bb6
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x39306(%rip) # 0x3b550
movl $0x0, 0x392e4(%rip)     # 0x3b538
movq 0x6ef5(%rip), %rcx      # 0x9150
movzbl (%rcx), %eax
cmpl $0x24, %eax
je 0x22a5
cmpl $0x3c, %eax
je 0x229e
cmpl $0x28, %eax
jne 0x22ac
incq %rcx
movq %rcx, 0x6ed9(%rip)      # 0x9150
callq 0x15b7
callq 0x2926
movq 0x6ec8(%rip), %rax      # 0x9150
cmpb $0x29, (%rax)
jne 0x2309
incq %rax
movq %rax, 0x6eb9(%rip)      # 0x9150
callq 0x15b7
jmp 0x22c3
callq 0x21b5
jmp 0x22c3
callq 0x28c1
jmp 0x22c3
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x22be
cmpl $0x27, %eax
je 0x22ca
cmpl $0x2d, %eax
jne 0x22d1
callq 0x2181
movl $0x1, %eax
popq %rcx
retq
callq 0x2383
jmp 0x22c3
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x22ef
cmpl $0x23, %eax
je 0x2302
cmpl $0x5b, %eax
jne 0x2315
callq 0x2615
jmp 0x22c3
callq 0x169e
leaq 0x2df75(%rip), %rdi     # 0x30270
callq 0x24c5
jmp 0x22c3
callq 0x2834
jmp 0x22c3
leaq 0x2f23(%rip), %rdi      # 0x5233
callq 0x13c6
leaq 0x2f2e(%rip), %rdi      # 0x524a
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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 0x6dc5(%rip), %rax      # 0x9150
leaq 0x1(%rax), %rcx
movq %rcx, 0x6dba(%rip)      # 0x9150
addq $0x2, %rax
leaq 0x2decf(%rip), %rbx     # 0x30270
movzbl -0x1(%rax), %ecx
cmpl $0x27, %ecx
je 0x23c9
testl %ecx, %ecx
je 0x23ff
leaq -0x1(%rax), %rcx
incq %rcx
movq %rcx, 0x6d94(%rip)      # 0x9150
movb -0x1(%rax), %cl
movb %cl, (%rbx)
incq %rbx
incq %rax
jmp 0x23a1
movq %rax, 0x6d80(%rip)      # 0x9150
callq 0x15b7
movb $0x0, (%rbx)
leaq 0x2de91(%rip), %rdi     # 0x30270
callq 0x2321
movq %rax, %rdi
callq 0x1c35
movl $0x4, %edi
movl %eax, %esi
callq 0x1bb6
movl $0x1, %eax
popq %rbx
retq
leaq 0x2dcc(%rip), %rdi      # 0x51d2
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2442
cmpq 0x5d13(%rip), %rdi      # 0x8140
je 0x2442
movq %r14, %rsi
movq %rbx, %rdx
callq 0x240b
movl %eax, %ecx
testl %eax, %eax
jns 0x24b9
jmp 0x2448
movl $0x0, (%rbx)
movq 0x30(%r15), %r15
testq %r15, %r15
je 0x24b4
cmpq 0x5ce8(%rip), %r15      # 0x8140
je 0x24b4
movl (%r15), %r12d
cmpq $0x4, %r12
jb 0x24b4
shrl $0x2, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x1090
movq 0x10(%r15,%r13,8), %rcx
movl (%rcx), %edx
shrl $0x2, %edx
cmpl %eax, %edx
movl %eax, %esi
cmovll %edx, %esi
testl %esi, %esi
jle 0x249e
movl %esi, %esi
xorl %edi, %edi
movb (%r14,%rdi), %r8b
cmpb 0x10(%rcx,%rdi), %r8b
jne 0x24a6
incq %rdi
cmpq %rdi, %rsi
jne 0x248b
movl (%rbx), %ecx
cmpl %eax, %edx
jne 0x24a8
jmp 0x24b9
movl (%rbx), %ecx
incl %ecx
movl %ecx, (%rbx)
incq %r13
cmpq %r12, %r13
jne 0x246a
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39009(%rip), %r15     # 0x3b4e0
testq %r15, %r15
jle 0x2506
leaq 0x3805d(%rip), %r12     # 0x3a540
xorl %r14d, %r14d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x25a0
incq %r14
addq $0x8, %r12
cmpq %r14, %r15
jne 0x24e6
movslq 0x38023(%rip), %r15     # 0x3a530
testq %r15, %r15
jle 0x2538
leaq 0x37f27(%rip), %r12     # 0x3a440
xorl %r14d, %r14d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x25a7
incq %r14
addq $0x8, %r12
cmpq %r14, %r15
jne 0x251c
leaq 0x2ca9(%rip), %rsi      # 0x51e8
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x25ae
movq 0x5b7e(%rip), %rdi      # 0x80d0
testq %rdi, %rdi
je 0x257c
movl $0x1, %r14d
leaq 0x5b6c(%rip), %r15      # 0x80d0
movq %rbx, %rsi
callq 0x10e0
testl %eax, %eax
je 0x25e7
movq (%r15,%r14,8), %rdi
incq %r14
testq %rdi, %rdi
jne 0x2564
movq 0x38fbd(%rip), %rdi     # 0x3b540
testq %rdi, %rdi
je 0x25c4
leaq 0x4(%rsp), %rdx
movq %rbx, %rsi
callq 0x240b
testl %eax, %eax
js 0x25c4
movl $0x1, %edi
jmp 0x25e3
movl $0x3, %edi
jmp 0x25f0
movl $0x2, %edi
jmp 0x25f0
movl $0x20, %edi
callq 0x1aea
movl $0x1, 0x38f76(%rip)     # 0x3b538
jmp 0x25f8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1496
testq %rax, %rax
je 0x2609
movq %rax, %rdi
callq 0x1c35
movl $0x4, %edi
movl %eax, %esi
jmp 0x25f3
addl $0x9, %r14d
movl $0x5, %edi
movl %r14d, %esi
callq 0x1bb6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2bde(%rip), %rdi      # 0x51ee
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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 0x6914(%rip), %rax      # 0x9150
leaq 0x1(%rax), %rcx
movq %rcx, 0x6909(%rip)      # 0x9150
movb 0x1(%rax), %cl
cmpb $0x3a, %cl
je 0x2863
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
jbe 0x2863
leaq 0x2da0f(%rip), %rcx     # 0x30270
jmp 0x2892
addq $0x2, %rax
leaq 0x2da02(%rip), %rcx     # 0x30270
movq %rax, 0x68db(%rip)      # 0x9150
movb -0x1(%rax), %dl
movb %dl, (%rcx)
incq %rcx
movb (%rax), %dl
incq %rax
cmpb $0x3a, %dl
je 0x286e
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x1a, %dl
jb 0x286e
movb $0x0, (%rcx)
callq 0x15b7
leaq 0x2d9cf(%rip), %rdi     # 0x30270
callq 0x180c
movq %rax, %rdi
callq 0x1c35
movl $0x4, %edi
movl %eax, %esi
callq 0x1bb6
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6887(%rip)            # 0x9150
movl $0x1, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x2876(%rip), %rdi      # 0x5153
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movq 0x6861(%rip), %rax      # 0x9150
movsbq (%rax), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x1c35
movl $0x4, %edi
movl %eax, %esi
callq 0x1bb6
incq 0x6836(%rip)            # 0x9150
callq 0x15b7
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x681e(%rip), %rax      # 0x9150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jae 0x2943
callq 0x223e
jmp 0x29b2
callq 0x169e
movq 0x6801(%rip), %rax      # 0x9150
cmpb $0x3a, (%rax)
jne 0x298b
cmpb $0x3d, 0x1(%rax)
jne 0x298b
addq $0x2, %rax
movq %rax, 0x67eb(%rip)      # 0x9150
callq 0x15b7
leaq 0x2d8ff(%rip), %rsi     # 0x30270
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1060
callq 0x2926
movq %rbx, %rdi
callq 0x3091
jmp 0x29c3
leaq 0x2d8de(%rip), %rdi     # 0x30270
callq 0x24c5
jmp 0x29b2
incq %rax
movq %rax, 0x67ad(%rip)      # 0x9150
callq 0x15b7
movl $0xf4, %edi
callq 0x1aea
callq 0x2e19
movq 0x6792(%rip), %rax      # 0x9150
cmpb $0x3b, (%rax)
je 0x2999
movl $0x1, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6774(%rip), %r15      # 0x9150
movb (%r15), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2ad9
callq 0x169e
testl %eax, %eax
jne 0x2ad2
leaq 0x2d871(%rip), %rbx     # 0x30270
leaq 0x56ea(%rip), %r14      # 0x80f0
cmpl $0x0, 0x38b2b(%rip)     # 0x3b538
setne %al
movq 0x56d9(%rip), %rsi      # 0x80f0
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x2a65
movb $0x1, %bpl
xorl %r15d, %r15d
incq %r15
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x2a44
movq (%r14,%r15,8), %rsi
incq %r15
testq %rsi, %rsi
jne 0x2a2a
jmp 0x2a5f
leal -0x1(%r15), %esi
movl $0xa, %edi
callq 0x1bb6
movq (%r14,%r15,8), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
jne 0x2a27
jmp 0x2ab3
testb $0x1, %bpl
je 0x2ab3
movl $0x81, %edi
callq 0x1aea
movq %rbx, %rdi
callq 0x180c
movq %rax, %rdi
callq 0x1c35
movl %eax, %ebp
cmpl $0x0, 0x38ab0(%rip)     # 0x3b538
je 0x2a9d
movl $0xfb, %edi
callq 0x1aea
movl %ebp, %edi
callq 0x1aea
jmp 0x2aa9
movl $0x9, %edi
movl %ebp, %esi
callq 0x1bb6
movl $0x0, 0x38a85(%rip)     # 0x3b538
movq 0x6696(%rip), %r15      # 0x9150
movb (%r15), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x2ad9
callq 0x169e
testl %eax, %eax
je 0x2a06
movq %r15, 0x6677(%rip)      # 0x9150
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x29ce
movq 0x664f(%rip), %rax      # 0x9150
movsbl (%rax), %edi
callq 0x1631
testl %eax, %eax
je 0x2c01
leaq 0x2d758(%rip), %rbx     # 0x30270
movq %rsp, %r14
leaq 0x55ee(%rip), %r15      # 0x8110
callq 0x1651
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1060
callq 0x223e
callq 0x29ce
cmpl $0x0, 0x389f5(%rip)     # 0x3b538
setne %al
movq 0x55c3(%rip), %rsi      # 0x8110
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x2b9c
movb $0x1, %bpl
xorl %r12d, %r12d
incq %r12
movq %r14, %rdi
callq 0x10e0
testl %eax, %eax
je 0x2b7a
movq (%r15,%r12,8), %rsi
incq %r12
testq %rsi, %rsi
jne 0x2b60
jmp 0x2b96
leal -0x1(%r12), %esi
movl $0xb, %edi
callq 0x1bb6
movq (%r15,%r12,8), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
jne 0x2b5d
jmp 0x2bea
testb $0x1, %bpl
je 0x2bea
movq %r14, %rdi
callq 0x180c
movq %rax, %rdi
callq 0x1c35
movl %eax, %ebp
movl $0x82, %edi
callq 0x1aea
cmpl $0x0, 0x38979(%rip)     # 0x3b538
je 0x2bde
movl $0xfb, %edi
callq 0x1aea
movl %ebp, %edi
callq 0x1aea
movl $0x0, 0x3895c(%rip)     # 0x3b538
jmp 0x2bea
movl $0x9, %edi
movl %ebp, %esi
callq 0x1bb6
movq 0x655f(%rip), %rax      # 0x9150
movsbl (%rax), %edi
callq 0x1631
testl %eax, %eax
jne 0x2b22
movl $0x1, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6535(%rip), %rax      # 0x9150
cmpb $0x5b, (%rax)
jne 0x2c9e
incq %rax
movq %rax, 0x6526(%rip)      # 0x9150
callq 0x15b7
movq 0x651a(%rip), %rax      # 0x9150
cmpb $0x5d, (%rax)
jne 0x2c62
movl $0x50, %edi
callq 0x1aea
movq 0x6504(%rip), %rax      # 0x9150
incq %rax
movq %rax, 0x64fa(%rip)      # 0x9150
callq 0x15b7
movl $0x1, %eax
popq %rcx
retq
callq 0x27f5
movq 0x64e2(%rip), %rax      # 0x9150
movb (%rax), %cl
cmpb $0x2e, %cl
jne 0x2c8d
incq %rax
movq %rax, 0x64d1(%rip)      # 0x9150
callq 0x15b7
movq 0x64c5(%rip), %rax      # 0x9150
movb (%rax), %cl
cmpb $0x5d, %cl
je 0x2c4c
movl $0xf5, %edi
callq 0x1aea
jmp 0x2c62
callq 0x223e
leaq 0x25d0(%rip), %rdi      # 0x527a
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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 0x1bb6
movl 0x37442(%rip), %r15d    # 0x3a110
xorl %edi, %edi
callq 0x1aea
xorl %edi, %edi
callq 0x1aea
callq 0x2c13
movl $0xf6, %edi
callq 0x1aea
movl 0x3741f(%rip), %ebp     # 0x3a110
xorl %edi, %edi
callq 0x1aea
xorl %edi, %edi
callq 0x1aea
movl 0x3740b(%rip), %esi     # 0x3a110
movl %r15d, %edi
callq 0x1b78
movq 0x643c(%rip), %r15      # 0x9150
movb (%r15), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2d3b
callq 0x169e
testl %eax, %eax
je 0x2d3b
leaq 0x2d541(%rip), %rdi     # 0x30270
movq %r14, %rsi
callq 0x10e0
testl %eax, %eax
je 0x2d6b
movq %r15, 0x640e(%rip)      # 0x9150
movl $0x5, %edi
movl %ebx, %esi
callq 0x1bb6
movl 0x373bc(%rip), %esi     # 0x3a110
movl %ebp, %edi
callq 0x1b78
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2c13
jmp 0x2d4e
// File: /workspace/github_c_makefile_star2_O3/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 0x387d2(%rip), %rax     # 0x3b550
movq %rax, 0x63cb(%rip)      # 0x9150
movl 0x37385(%rip), %ebx     # 0x3a110
callq 0x2c13
movl $0xf, %edi
movl %ebp, %esi
callq 0x1bb6
movl 0x3736e(%rip), %ebp     # 0x3a110
xorl %edi, %edi
callq 0x1aea
xorl %edi, %edi
callq 0x1aea
movq 0x6399(%rip), %rax      # 0x9150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2e0d
callq 0x169e
testl %eax, %eax
je 0x2e0d
callq 0x2c13
movl $0xf5, %edi
callq 0x1aea
movl $0xf6, %edi
callq 0x1aea
movl %ebx, %edi
callq 0x1b34
movl 0x37320(%rip), %esi     # 0x3a110
movl %ebp, %edi
callq 0x1b78
movl $0x50, %edi
callq 0x1aea
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2490(%rip), %rdi      # 0x52a4
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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 0x3843d(%rip), %r15     # 0x3b4e0
testq %r15, %r15
jle 0x30ce
leaq 0x37491(%rip), %r12     # 0x3a540
xorl %r14d, %r14d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x30f4
incq %r14
addq $0x8, %r12
cmpq %r14, %r15
jne 0x30b2
movq 0x3846b(%rip), %rdi     # 0x3b540
testq %rdi, %rdi
je 0x3112
leaq 0x4(%rsp), %rdx
movq %rbx, %rsi
callq 0x240b
testl %eax, %eax
js 0x3112
movl $0x6, %edi
movl %eax, %esi
jmp 0x30fc
movl $0x7, %edi
movl %r14d, %esi
callq 0x1bb6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21de(%rip), %rdi      # 0x52f7
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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, 0x3841f(%rip)     # 0x3b548
movq 0x6020(%rip), %rax      # 0x9150
cmpb $0x0, (%rax)
je 0x316e
callq 0x27f5
movl $0xf5, %edi
callq 0x1aea
movq 0x6005(%rip), %rax      # 0x9150
movb (%rax), %cl
cmpb $0x2e, %cl
jne 0x316a
incq %rax
movq %rax, 0x5ff4(%rip)      # 0x9150
callq 0x15b7
movq 0x5fe8(%rip), %rax      # 0x9150
movb (%rax), %cl
testb %cl, %cl
jne 0x3135
movl $0xf1, %edi
callq 0x1aea
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5fbc(%rip), %rax      # 0x9150
movb (%rax), %al
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x31ef
movsbl %al, %edi
callq 0x1631
testl %eax, %eax
je 0x32b9
callq 0x1651
leaq 0x2d0b1(%rip), %rsi     # 0x30270
movq %rsp, %rdi
callq 0x1060
movq 0x5f82(%rip), %rax      # 0x9150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x32c5
callq 0x169e
leaq 0x2d088(%rip), %rdi     # 0x30270
callq 0x1cd1
jmp 0x326d
callq 0x169e
testl %eax, %eax
je 0x325e
movq %rsp, %r14
movb $0x0, (%r14)
leaq 0x2d06a(%rip), %r15     # 0x30270
movq 0x5f43(%rip), %r12      # 0x9150
movq %r14, %rdi
movq %r15, %rsi
callq 0x1120
movb (%r12), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x32ad
callq 0x169e
testl %eax, %eax
jne 0x32ad
movq %r15, %rdi
callq 0x1cd1
movq 0x5f10(%rip), %r12      # 0x9150
movb (%r12), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x3255
callq 0x169e
testl %eax, %eax
jne 0x3206
movq %r12, 0x5ef4(%rip)      # 0x9150
jmp 0x326d
leaq 0x2d00b(%rip), %rsi     # 0x30270
movq %rsp, %rdi
callq 0x1060
movq %rsp, %r14
movq %r14, %rdi
callq 0x180c
movq %rax, 0x10(%rbx)
movq 0x382bd(%rip), %rax     # 0x3b540
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq 0x20cb(%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 0x2060(%rip), %rdi      # 0x5314
callq 0x13c6
leaq 0x2084(%rip), %rdi      # 0x5344
callq 0x13c6
leaq 0x2067(%rip), %rdi      # 0x5333
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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, 0x38206(%rip)     # 0x3b4e0
movl %eax, 0x38204(%rip)     # 0x3b4e4
movq 0x5e69(%rip), %rax      # 0x9150
cmpb $0x7c, (%rax)
jne 0x3344
incq %rax
movq %rax, 0x5e5a(%rip)      # 0x9150
callq 0x15b7
movq 0x5e4e(%rip), %rcx      # 0x9150
movb (%rcx), %al
cmpb $0x7c, %al
je 0x3335
leaq 0x2cf61(%rip), %rbx     # 0x30270
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x334b
callq 0x169e
testl %eax, %eax
jne 0x3357
movq %rbx, %rdi
callq 0x1d1f
movq 0x5e21(%rip), %rcx      # 0x9150
movb (%rcx), %al
cmpb $0x7c, %al
jne 0x330f
incq %rcx
movq %rcx, 0x5e11(%rip)      # 0x9150
callq 0x15b7
movl $0x1, %eax
popq %rbx
retq
leaq 0x201a(%rip), %rdi      # 0x536c
callq 0x13c6
leaq 0x1eb6(%rip), %rdi      # 0x5214
callq 0x13c6
// File: /workspace/github_c_makefile_star2_O3/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 0x317f
callq 0x32d1
callq 0x311e
callq 0x1c7c
movq %rax, 0x20(%rbx)
callq 0x1bd6
movq %rax, 0x18(%rbx)
movq $0x27, 0x28(%rbx)
movslq 0x3814d(%rip), %rax     # 0x3b4e4
leaq 0x1(,%rax,2), %rax
movq %rax, 0x30(%rbx)
movq 0x38196(%rip), %rax     # 0x3b540
movq %rax, 0x38(%rbx)
leaq 0x4d9b(%rip), %rdi      # 0x8150
callq 0x2321
movq %rax, 0x40(%rbx)
movq 0x38193(%rip), %rax     # 0x3b558
testq %rax, %rax
jne 0x33dd
leaq 0x1fab(%rip), %rdi      # 0x537c
callq 0x2321
movq %rax, 0x3817b(%rip)     # 0x3b558
movq %rax, 0x48(%rbx)
movslq 0x2ce84(%rip), %rax     # 0x3026c
leaq 0x1(,%rax,2), %rax
movq %rax, 0x50(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
xorl %eax, %eax
movl %eax, 0x36d0c(%rip)     # 0x3a110
movl %eax, 0x36d0a(%rip)     # 0x3a114
movl %eax, 0x37120(%rip)     # 0x3a530
movq $0x0, 0x38125(%rip) # 0x3b540
movl %eax, 0x380bf(%rip)     # 0x3b4e0
movl %eax, 0x380bd(%rip)     # 0x3b4e4
callq 0x311e
leaq 0x2140(%rip), %rdi      # 0x5573
callq 0x1070
movl $0x9, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x1f80(%rip), %rdi      # 0x53cc
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
leaq 0x1f37(%rip), %rdi      # 0x5395
callq 0x180c
movq %rax, 0x10(%rbx)
callq 0x1c7c
movq %rax, 0x20(%rbx)
callq 0x1bd6
movq %rax, 0x18(%rbx)
movq $0x19, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r15
movl (%rdi), %edi
shrl $0x2, %edi
incl %edi
callq 0x12bb
movq %rax, %r14
movq 0x8(%r15), %rax
movq %rax, 0x8(%r14)
movl %ebx, %r13d
testl %ebx, %ebx
je 0x34ca
leaq 0x10(%r15), %rsi
leaq 0x10(%r14), %rdi
leaq (,%r13,8), %rdx
callq 0x10f0
movq %r12, 0x10(%r14,%r13,8)
movl (%r15), %eax
shrl $0x2, %eax
cmpl %ebx, %eax
jbe 0x34fa
leaq (%r14,%r13,8), %rdi
addq $0x18, %rdi
leaq (%r15,%r13,8), %rsi
addq $0x10, %rsi
notl %ebx
addl %ebx, %eax
leaq 0x8(,%rax,8), %rdx
callq 0x10f0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %r15
movl (%rdi), %eax
xorl %r12d, %r12d
cmpq $0x4, %rax
jb 0x357f
movl %eax, %r12d
shrl $0x2, %r12d
movl (%rdx), %eax
shrl $0x2, %eax
xorl %r13d, %r13d
movq 0x10(%rdi,%r13,8), %rsi
movl (%rsi), %ecx
shrl $0x2, %ecx
cmpl %eax, %ecx
movl %eax, %r8d
cmovbl %ecx, %r8d
testl %r8d, %r8d
je 0x356d
movl %r8d, %r8d
xorl %r9d, %r9d
movb 0x10(%rsi,%r9), %r10b
cmpb %r10b, 0x10(%rdx,%r9)
jne 0x3575
incq %r9
cmpq %r9, %r8
jne 0x3559
cmpl %ecx, %eax
jb 0x358c
jne 0x3577
jmp 0x35b4
jl 0x358c
incq %r13
cmpq %r12, %r13
jne 0x353b
movl %r12d, %esi
callq 0x3486
movl %r12d, %r13d
jmp 0x3594
movl %r13d, %esi
callq 0x3486
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
callq 0x3486
movq %rax, 0x18(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1a85(%rip), %rdi      # 0x5040
leaq 0x1dd8(%rip), %rsi      # 0x539a
leaq 0x1de4(%rip), %rdx      # 0x53ad
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
callq 0x169e
leaq 0x2cc87(%rip), %rdi     # 0x30270
movl $0x1, %esi
callq 0x1496
movq %rax, 0x37f46(%rip)     # 0x3b540
testq %rax, %rax
je 0x3673
callq 0x153a
leaq 0x4b45(%rip), %rax      # 0x8150
movq %rax, 0x5b3e(%rip)      # 0x9150
callq 0x15b7
movl $0x9, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x1da1(%rip), %rdi      # 0x53cc
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movl %ebp, 0x36ad2(%rip)     # 0x3a110
movl %ebp, 0x36ad0(%rip)     # 0x3a114
movl $0x1, 0x36ee2(%rip)     # 0x3a530
movq %rbx, %rdi
callq 0x3363
movq 0x37ee3(%rip), %rax     # 0x3b540
movq 0x20(%rax), %rdi
movq 0x10(%rbx), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3507
leaq 0x19c6(%rip), %rdi      # 0x5040
leaq 0x1d3a(%rip), %rsi      # 0x53bb
leaq 0x2cbe8(%rip), %rdx     # 0x30270
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x169e
leaq 0x2ca37(%rip), %r14     # 0x30270
movq %r14, %rdi
callq 0x1160
movq %rax, %rbx
callq 0x169e
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
callq 0x15b7
movq 0x58f0(%rip), %rdi      # 0x9150
callq 0x1160
movq %rax, %r15
leaq 0x48e1(%rip), %r12      # 0x8150
leaq 0x1ba8(%rip), %rsi      # 0x541e
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1130
leaq 0x48cc(%rip), %r13      # 0x8159
movq %r13, 0x58bc(%rip)      # 0x9150
callq 0x3699
leaq 0x1b9b(%rip), %rsi      # 0x543b
movq %r12, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1130
movq %r13, 0x5893(%rip)      # 0x9150
callq 0x3699
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
testl %edi, %edi
js 0x3922
movq %rsi, %rbx
cmpl $0xff, %ebp
jb 0x3912
movl $0xff, %edi
movq %rbx, %rsi
callq 0x10c0
addl $0xffffff01, %ebp       # imm = 0xFFFFFF01
cmpl $0xfe, %ebp
ja 0x38f7
movl %ebp, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10c0
movslq %ebp, %rdx
leaq 0x1714(%rip), %rdi      # 0x5040
leaq 0x1b21(%rip), %rsi      # 0x5454
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rdi, 0x460d(%rip)      # 0x8140
je 0x3b91
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
movq 0x10(%rdi), %rdx
movl (%rcx), %eax
shrl $0x2, %eax
movl (%rdx), %edi
shrl $0x2, %edi
cmpl %eax, %edi
movl %eax, %r8d
cmovbl %edi, %r8d
testl %r8d, %r8d
je 0x3b72
movl %r8d, %r8d
xorl %r9d, %r9d
movb 0x10(%rdx,%r9), %r10b
cmpb %r10b, 0x10(%rcx,%r9)
jne 0x3b9f
incq %r9
cmpq %r9, %r8
jne 0x3b5e
movl $0x18, %r14d
cmpl %edi, %eax
jb 0x3b82
movl $0x20, %r14d
movq (%rbx,%r14), %rdi
callq 0x3b28
movq %rax, (%rbx,%r14)
jmp 0x3b94
movq %rsi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x18, %r14d
jge 0x3b7c
jmp 0x3b82
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x14ec(%rip), %rdi      # 0x50b4
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x2c6e6(%rip)     # 0x302c0
je 0x3c4f
movq %rbx, (%rsp)
movq 0x10(%rbx), %r14
leaq 0x2c6e5(%rip), %r13     # 0x302d0
xorl %ebp, %ebp
movq (%r13), %rbx
movq 0x4548(%rip), %r15      # 0x8140
movl $0x3, %edi
callq 0x12bb
movq %rax, %r12
leaq 0x14a3(%rip), %rdi      # 0x50af
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r12)
movq %rbx, 0x10(%r12)
movq %r15, 0x18(%r12)
movq %r15, 0x20(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3b28
movq %rax, %r14
incq %rbp
movl 0x2c682(%rip), %eax     # 0x302c0
addq $0x8, %r13
cmpq %rax, %rbp
jb 0x3bed
movq (%rsp), %rbx
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x378bd(%rip), %rbx     # 0x3b530
leaq 0x143f(%rip), %rdi      # 0x50b9
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
xorl %edi, %edi
callq 0x12bb
movq %rax, %r14
leaq 0x14e9(%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 0x14d0(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movq %r14, 0x18(%rbx)
movl 0x548c(%rip), %r13d     # 0x9158
testl %r13d, %r13d
jle 0x3d30
xorl %r12d, %r12d
leaq 0x17e7(%rip), %r14      # 0x54c2
xorl %ebp, %ebp
leaq 0x547c(%rip), %rax      # 0x9160
movq (%r12,%rax), %r15
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
je 0x3d21
movq %r15, %rdi
callq 0x180c
leaq 0x18cd5(%rip), %rcx     # 0x1c9e0
movq (%r12,%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3507
movl 0x5437(%rip), %r13d     # 0x9158
incq %rbp
movslq %r13d, %rax
addq $0x8, %r12
cmpq %rax, %rbp
jl 0x3cdd
leaq 0x1790(%rip), %rdi      # 0x54c7
callq 0x180c
movq %rbx, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3507
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
movslq 0x53f8(%rip), %rax      # 0x9158
testq %rax, %rax
jle 0x3d86
shlq $0x3, %rax
xorl %ecx, %ecx
leaq 0x18c6e(%rip), %rdx     # 0x1c9e0
movq (%rcx,%rdx), %rsi
cmpq $0x0, 0x8(%rsi)
je 0x3d88
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x3d72
popq %rax
retq
leaq 0x53d1(%rip), %rax      # 0x9160
movq (%rcx,%rax), %rdx
leaq 0x12a6(%rip), %rdi      # 0x5040
leaq 0x1730(%rip), %rsi      # 0x54d1
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
cmpq $0x0, 0x20(%rdi)
movq 0x38(%rdi), %rdi
je 0xfdb5
movq 0x18(%rax), %rax
jmpq *%rax
pushq %rax
callq *0x48(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
movq $-0x1, %rcx
cmoveq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0x4e(%rip), %rax        # 0xfe59
movq %rax, (%rdi)
leaq 0x97(%rip), %rax        # 0xfeac
movq %rax, 0x8(%rdi)
leaq 0xa2(%rip), %rax        # 0xfec2
movq %rax, 0x10(%rdi)
leaq 0xad(%rip), %rax        # 0xfed8
movq %rax, 0x18(%rdi)
leaq 0xaa(%rip), %rax        # 0xfee0
movq %rax, 0x20(%rdi)
leaq 0xc7(%rip), %rax        # 0xff08
movq %rax, 0x28(%rdi)
leaq 0xc4(%rip), %rax        # 0xff10
movq %rax, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
retq