LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2cce9(%rip), %rbx     # 0x2f270
pushq $0xa
popq %rbp
pushq $0x1
popq %r14
movq 0x5bbb(%rip), %r15      # 0x8150
movb (%r15), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2655
callq 0x1582
testl %eax, %eax
jne 0x264e
cmpl $0x0, 0x37f80(%rip)     # 0x3a538
je 0x25f4
movl $0x81, %edi
callq 0x1889
movq %rbx, %rdi
callq 0x1696
movq %rax, %rdi
callq 0x1984
movl %eax, %r15d
cmpl $0x0, 0x37f5a(%rip)     # 0x3a538
je 0x2637
movl $0xfb, %edi
callq 0x1889
movl %r15d, %edi
callq 0x1889
jmp 0x2642
xorl %r15d, %r15d
leaq 0x4af2(%rip), %r12      # 0x70f0
xorl %r13d, %r13d
movq (%r12), %rsi
testq %rsi, %rsi
je 0x262c
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
jne 0x2623
movl %ebp, %edi
movl %r15d, %esi
callq 0x191c
movl %r14d, %r13d
addq $0x8, %r12
incl %r15d
jmp 0x2601
testl %r13d, %r13d
jne 0x258e
jmp 0x25ba
pushq $0x9
popq %rdi
movl %r15d, %esi
callq 0x191c
andl $0x0, 0x37eef(%rip)     # 0x3a538
jmp 0x258e
movq %r15, 0x5afb(%rip)      # 0x8150
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: 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 %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
callq 0x2575
leaq 0x2cbef(%rip), %r15     # 0x2f270
movq %rsp, %r14
pushq $0xb
popq %rbp
pushq $0x1
popq %rbx
movq 0x5abf(%rip), %rax      # 0x8150
movsbl (%rax), %edi
callq 0x1517
testl %eax, %eax
je 0x2762
callq 0x1535
movq %r14, %rdi
movq %r15, %rsi
callq 0x1060
callq 0x1e5f
callq 0x2575
cmpl $0x0, 0x37e76(%rip)     # 0x3a538
je 0x2705
movq %r14, %rdi
callq 0x1696
movq %rax, %rdi
callq 0x1984
movl %eax, %r12d
movl $0x82, %edi
callq 0x1889
cmpl $0x0, 0x37e50(%rip)     # 0x3a538
je 0x2752
movl $0xfb, %edi
callq 0x1889
movl %r12d, %edi
callq 0x1889
andl $0x0, 0x37e35(%rip)     # 0x3a538
jmp 0x268a
xorl %r12d, %r12d
leaq 0x4a01(%rip), %r13      # 0x7110
xorl %r15d, %r15d
movq (%r13), %rsi
testq %rsi, %rsi
je 0x273d
movq %r14, %rdi
callq 0x10e0
testl %eax, %eax
jne 0x2734
movl %ebp, %edi
movl %r12d, %esi
callq 0x191c
movl %ebx, %r15d
addq $0x8, %r13
incl %r12d
jmp 0x2712
testl %r15d, %r15d
leaq 0x2cb29(%rip), %r15     # 0x2f270
jne 0x268a
jmp 0x26c4
pushq $0x9
popq %rdi
movl %r12d, %esi
callq 0x191c
jmp 0x268a
pushq $0x1
popq %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: 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 0x59d4(%rip), %rax      # 0x8150
cmpb $0x5b, (%rax)
jne 0x27fb
incq %rax
movq %rax, 0x59c5(%rip)      # 0x8150
callq 0x149d
movq 0x59b9(%rip), %rax      # 0x8150
cmpb $0x5d, (%rax)
jne 0x27bf
pushq $0x50
popq %rdi
callq 0x1889
movq 0x59a5(%rip), %rax      # 0x8150
incq %rax
movq %rax, 0x599b(%rip)      # 0x8150
callq 0x149d
pushq $0x1
popq %rax
popq %rcx
retq
callq 0x23bc
movq 0x5985(%rip), %rax      # 0x8150
movb (%rax), %cl
cmpb $0x2e, %cl
jne 0x27ea
incq %rax
movq %rax, 0x5974(%rip)      # 0x8150
callq 0x149d
movq 0x5968(%rip), %rax      # 0x8150
movb (%rax), %cl
cmpb $0x5d, %cl
je 0x27ab
movl $0xf5, %edi
callq 0x1889
jmp 0x27bf
callq 0x1e5f
leaq 0x1a37(%rip), %rdi      # 0x423e
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xf
popq %rdi
callq 0x191c
movl 0x368e7(%rip), %r15d    # 0x39110
xorl %edi, %edi
callq 0x18c0
callq 0x2774
movl $0xf6, %edi
callq 0x1889
movl 0x368cb(%rip), %ebp     # 0x39110
xorl %edi, %edi
callq 0x18c0
movl 0x368be(%rip), %esi     # 0x39110
movl %r15d, %edi
callq 0x18f1
movq 0x58ef(%rip), %r15      # 0x8150
movb (%r15), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2888
callq 0x1582
testl %eax, %eax
je 0x2888
leaq 0x2c9f4(%rip), %rdi     # 0x2f270
movq %r14, %rsi
callq 0x10e0
testl %eax, %eax
je 0x28b4
movq %r15, 0x58c1(%rip)      # 0x8150
pushq $0x5
popq %rdi
movl %ebx, %esi
callq 0x191c
movl 0x36871(%rip), %esi     # 0x39110
movl %ebp, %edi
callq 0x18f1
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2774
jmp 0x2899
// File: /workspace/github_c_makefile_star2_O2/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 0x37c89(%rip), %rax     # 0x3a550
movq %rax, 0x5882(%rip)      # 0x8150
movl 0x3683c(%rip), %ebx     # 0x39110
callq 0x2774
pushq $0xf
popq %rdi
movl %ebp, %esi
callq 0x191c
movl 0x36827(%rip), %ebp     # 0x39110
xorl %edi, %edi
callq 0x18c0
movq 0x5859(%rip), %rax      # 0x8150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2949
callq 0x1582
testl %eax, %eax
je 0x2949
callq 0x2774
movl $0xf5, %edi
callq 0x1889
movl $0xf6, %edi
callq 0x1889
movl %ebx, %edi
callq 0x18c0
movl 0x367e0(%rip), %esi     # 0x39110
movl %ebp, %edi
callq 0x18f1
pushq $0x50
popq %rdi
callq 0x1889
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1918(%rip), %rdi      # 0x4268
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x37951(%rip), %r15d    # 0x3a4e0
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
leaq 0x369a0(%rip), %r12     # 0x39540
cmpq %r14, %r15
je 0x2bbe
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x2be2
incq %r14
addq $0x8, %r12
jmp 0x2ba0
movq 0x3797b(%rip), %rdi     # 0x3a540
testq %rdi, %rdi
je 0x2bfc
leaq 0x4(%rsp), %rdx
movq %rbx, %rsi
callq 0x200f
testl %eax, %eax
js 0x2bfc
pushq $0x6
popq %rdi
movl %eax, %esi
jmp 0x2be8
pushq $0x7
popq %rdi
movl %r14d, %esi
callq 0x191c
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x16b8(%rip), %rdi      # 0x42bb
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/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, 0x37935(%rip)     # 0x3a548
movq 0x5536(%rip), %rax      # 0x8150
cmpb $0x0, (%rax)
je 0x2c4b
callq 0x23bc
movl $0xf5, %edi
callq 0x1889
movq 0x551b(%rip), %rax      # 0x8150
cmpb $0x2e, (%rax)
jne 0x2c1a
incq %rax
movq %rax, 0x550c(%rip)      # 0x8150
callq 0x149d
jmp 0x2c13
movl $0xf1, %edi
callq 0x1889
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x54e1(%rip), %rax      # 0x8150
movb (%rax), %al
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x2cca
movsbl %al, %edi
callq 0x1517
testl %eax, %eax
je 0x2d90
callq 0x1535
leaq 0x2c5d6(%rip), %rsi     # 0x2f270
movq %rsp, %rdi
callq 0x1060
movq 0x54a7(%rip), %rax      # 0x8150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x2d9c
callq 0x1582
leaq 0x2c5ad(%rip), %rdi     # 0x2f270
callq 0x1a1a
jmp 0x2d46
callq 0x1582
testl %eax, %eax
je 0x2d37
movq %rsp, %r14
movb $0x0, (%r14)
leaq 0x2c58f(%rip), %r15     # 0x2f270
movq %r14, %rdi
movq %r15, %rsi
callq 0x1120
movq 0x545d(%rip), %rax      # 0x8150
movb (%rax), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2d84
callq 0x1582
testl %eax, %eax
jne 0x2d84
movq %r15, %rdi
callq 0x1a1a
movq 0x5437(%rip), %r12      # 0x8150
movb (%r12), %al
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x2d2e
callq 0x1582
testl %eax, %eax
jne 0x2ce1
movq %r12, 0x541b(%rip)      # 0x8150
jmp 0x2d46
leaq 0x2c532(%rip), %rsi     # 0x2f270
movq %rsp, %rdi
callq 0x1060
movq %rsp, %r14
movq %r14, %rdi
callq 0x1696
movq %rax, 0x10(%rbx)
movq 0x377e4(%rip), %rax     # 0x3a540
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq 0x15b6(%rip), %rdi      # 0x4321
movq %r14, %rdx
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x154d(%rip), %rdi      # 0x42d8
callq 0x12ef
leaq 0x1571(%rip), %rdi      # 0x4308
callq 0x12ef
leaq 0x1554(%rip), %rdi      # 0x42f7
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x37730(%rip)     # 0x3a4e0
andl $0x0, 0x3772d(%rip)     # 0x3a4e4
movq 0x5392(%rip), %rax      # 0x8150
cmpb $0x7c, (%rax)
jne 0x2e10
incq %rax
movq %rax, 0x5383(%rip)      # 0x8150
callq 0x149d
leaq 0x2c497(%rip), %rbx     # 0x2f270
movq 0x5370(%rip), %rcx      # 0x8150
movb (%rcx), %al
cmpb $0x7c, %al
je 0x2e01
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
jbe 0x2e15
callq 0x1582
testl %eax, %eax
jne 0x2e21
movq %rbx, %rdi
callq 0x1a55
jmp 0x2dd9
incq %rcx
movq %rcx, 0x5345(%rip)      # 0x8150
callq 0x149d
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x1514(%rip), %rdi      # 0x4330
callq 0x12ef
leaq 0x13b0(%rip), %rdi      # 0x41d8
callq 0x12ef
// File: /workspace/github_c_makefile_star2_O2/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 0x2c5a
callq 0x2da8
callq 0x2c08
callq 0x19b8
movq %rax, 0x20(%rbx)
callq 0x193c
movq %rax, 0x18(%rbx)
movq $0x27, 0x28(%rbx)
movslq 0x37683(%rip), %rax     # 0x3a4e4
leaq 0x1(,%rax,2), %rax
movq %rax, 0x30(%rbx)
movq 0x376cc(%rip), %rax     # 0x3a540
movq %rax, 0x38(%rbx)
leaq 0x42d1(%rip), %rdi      # 0x7150
callq 0x1f3a
movq %rax, 0x40(%rbx)
movq 0x376c9(%rip), %rax     # 0x3a558
testq %rax, %rax
jne 0x2ea7
leaq 0x14a5(%rip), %rdi      # 0x4340
callq 0x1f3a
movq %rax, 0x376b1(%rip)     # 0x3a558
movq %rax, 0x48(%rbx)
movslq 0x2c3ba(%rip), %rax     # 0x2f26c
leaq 0x1(,%rax,2), %rax
movq %rax, 0x50(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x36245(%rip)     # 0x39110
andl $0x0, 0x36242(%rip)     # 0x39114
andl $0x0, 0x36657(%rip)     # 0x39530
andq $0x0, 0x3765f(%rip)     # 0x3a540
andl $0x0, 0x375f8(%rip)     # 0x3a4e0
andl $0x0, 0x375f5(%rip)     # 0x3a4e4
callq 0x2c08
leaq 0x163c(%rip), %rdi      # 0x4537
callq 0x1070
pushq $0x9
popq %rdi
callq 0x1289
movq %rax, %rbx
leaq 0x147e(%rip), %rdi      # 0x4390
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%rbx)
leaq 0x1435(%rip), %rdi      # 0x4359
callq 0x1696
movq %rax, 0x10(%rbx)
callq 0x19b8
movq %rax, 0x20(%rbx)
callq 0x193c
movq %rax, 0x18(%rbx)
movq $0x19, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rdi), %rbp
movq 0x18(%rdi), %r15
movl (%rbp), %r14d
shrl $0x2, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2fef
movq 0x10(%rbp,%r12,8), %rsi
movq %r13, %rdi
callq 0x167d
testl %eax, %eax
js 0x2fec
je 0x3023
incq %r12
jmp 0x2fcf
movl %r12d, %r14d
movq %rbp, %rdi
movl %r14d, %esi
movq %r13, %rdx
callq 0x2f4c
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movl %r14d, %esi
movq (%rsp), %rdx
callq 0x2f4c
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1334(%rip), %rdi      # 0x435e
leaq 0x1340(%rip), %rsi      # 0x4371
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/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 0x1582
leaq 0x2c041(%rip), %r14     # 0x2f270
movq %r14, %rdi
callq 0x1160
movq %rax, %rbx
callq 0x1582
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
callq 0x149d
movq 0x4efa(%rip), %rdi      # 0x8150
callq 0x1160
movq %rax, %r15
leaq 0x3eeb(%rip), %r12      # 0x7150
leaq 0x1176(%rip), %rsi      # 0x43e2
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1130
leaq 0x3ed6(%rip), %r13      # 0x7159
movq %r13, 0x4ec6(%rip)      # 0x8150
callq 0x30d7
leaq 0x1169(%rip), %rsi      # 0x43ff
movq %r12, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1130
movq %r13, 0x4e9d(%rip)      # 0x8150
callq 0x30d7
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movslq %edi, %rbx
testl %ebx, %ebx
js 0x3316
cmpl $0xff, %ebx
jb 0x3305
movl $0xff, %edi
movq %r14, %rsi
callq 0x10c0
addq $-0xff, %rbx
jmp 0x32e3
movl %ebx, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10c0
leaq 0x10fb(%rip), %rdi      # 0x4418
movq %rbx, %rsi
callq 0x126c
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2bd7e(%rip), %r15     # 0x2f2d0
xorl %r12d, %r12d
callq 0x17c4
movq %rax, %rbx
movl 0x2bd5d(%rip), %eax     # 0x2f2c0
cmpq %rax, %r12
jae 0x3596
movq 0x10(%rbx), %r14
movq (%r15), %rdi
movq 0x3bca(%rip), %rdx      # 0x7140
movq %rdx, %rsi
callq 0x1777
movq %r14, %rdi
movq %rax, %rsi
callq 0x34f8
movq %rax, 0x10(%rbx)
incq %r12
addq $0x8, %r15
jmp 0x355d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: 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 0x36f79(%rip), %rbx     # 0x3a530
leaq 0xabf(%rip), %rdi       # 0x407d
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x1390
movq %rax, 0x8(%rbx)
callq 0x181e
movq %rax, 0x10(%rbx)
xorl %edi, %edi
callq 0x1840
movq %rax, 0x18(%rbx)
movl 0x4b71(%rip), %r14d     # 0x8158
pushq $0x4
popq %r15
xorl %ebp, %ebp
movslq %r14d, %rax
cmpq %rax, %rbp
jge 0x3646
leaq 0x4b64(%rip), %rax      # 0x8160
movq (%r13,%rax), %r12
movq %r12, %rdi
leaq 0xe7b(%rip), %rsi       # 0x4486
movq %r15, %rdx
callq 0x1050
testl %eax, %eax
je 0x363d
movq %r12, %rdi
callq 0x1696
leaq 0x183ba(%rip), %rcx     # 0x1b9e0
movq (%r13,%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fa7
movl 0x4b1b(%rip), %r14d     # 0x8158
incq %rbp
addq $0x8, %r13
jmp 0x35ed
leaq 0xe3e(%rip), %rdi       # 0x448b
callq 0x1696
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 0x2fa7
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x4ae3(%rip), %ecx      # 0x8158
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
shlq $0x3, %rcx
leaq 0x18359(%rip), %rdx     # 0x1b9e0
cmpq %rax, %rcx
je 0x36b3
movq (%rax,%rdx), %rsi
addq $0x8, %rax
cmpq $0x0, 0x8(%rsi)
jne 0x3687
leaq 0x4abe(%rip), %rcx      # 0x8160
movq -0x8(%rax,%rcx), %rsi
leaq 0xde7(%rip), %rdi       # 0x4495
callq 0x126c
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd2a5
movq 0x18(%rax), %rax
jmpq *%rax
pushq %rax
callq *0x48(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
pushq $-0x1
popq %rcx
cmoveq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
andq $0x0, (%rdi)
movq (%rsi), %rax
movq %rax, 0x40(%rdi)
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups 0x28(%rsi), %xmm0
movups %xmm0, 0x28(%rdi)
movq 0x38(%rsi), %rax
movq %rax, 0x38(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x48(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b(%rip), %rax        # 0xd33f
movq %rax, (%rdi)
leaq 0x94(%rip), %rax        # 0xd392
movq %rax, 0x8(%rdi)
leaq 0x9d(%rip), %rax        # 0xd3a6
movq %rax, 0x10(%rdi)
leaq 0xa6(%rip), %rax        # 0xd3ba
movq %rax, 0x18(%rdi)
leaq 0xa3(%rip), %rax        # 0xd3c2
movq %rax, 0x20(%rdi)
leaq 0xbd(%rip), %rax        # 0xd3e7
movq %rax, 0x28(%rdi)
leaq 0xba(%rip), %rax        # 0xd3ef
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edx, %eax
andl $0x3, %eax
movb $0x1, %cl
cmpl $0x1, %eax
jne 0xd354
leaq 0x2fcae(%rip), %rax     # 0x3d000
jmp 0xd377
testb $0x4, %dl
jne 0xd370
shrl $0x3, %edx
xorl %eax, %eax
andl $0x1, %edx
leaq 0x2fc9f(%rip), %rcx     # 0x3d007
cmovneq %rcx, %rax
movl %edx, %ecx
jmp 0xd377
leaq 0x2fc8c(%rip), %rax     # 0x3d003
testq %rsi, %rsi
sete %dl
xorb $0x1, %cl
orb %dl, %cl
jne 0xd38f
movq %rsi, %rdi
movq %rax, %rsi
jmp 0xce40
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: fill_fopen64_filefunc
void fill_fopen64_filefunc(zlib_filefunc64_def* pzlib_filefunc_def) {
    pzlib_filefunc_def->zopen64_file = fopen64_file_func;
    pzlib_filefunc_def->zread_file = fread_file_func;
    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
    pzlib_filefunc_def->ztell64_file = ftell64_file_func;
    pzlib_filefunc_def->zseek64_file = fseek64_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 0x4b(%rip), %rax        # 0xd449
movq %rax, (%rdi)
leaq -0x76(%rip), %rax       # 0xd392
movq %rax, 0x8(%rdi)
leaq -0x6d(%rip), %rax       # 0xd3a6
movq %rax, 0x10(%rdi)
leaq 0x7e(%rip), %rax        # 0xd49c
movq %rax, 0x18(%rdi)
leaq 0x7b(%rip), %rax        # 0xd4a4
movq %rax, 0x20(%rdi)
leaq -0x4d(%rip), %rax       # 0xd3e7
movq %rax, 0x28(%rdi)
leaq -0x50(%rip), %rax       # 0xd3ef
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: fopen64_file_func
static voidpf ZCALLBACK fopen64_file_func(voidpf opaque, const void* 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_FUNC((const char*)filename, mode_fopen);
    return file;
}

// Assembly:
movl %edx, %eax
andl $0x3, %eax
movb $0x1, %cl
cmpl $0x1, %eax
jne 0xd45e
leaq 0x2fba4(%rip), %rax     # 0x3d000
jmp 0xd481
testb $0x4, %dl
jne 0xd47a
shrl $0x3, %edx
xorl %eax, %eax
andl $0x1, %edx
leaq 0x2fb95(%rip), %rcx     # 0x3d007
cmovneq %rcx, %rax
movl %edx, %ecx
jmp 0xd481
leaq 0x2fb82(%rip), %rax     # 0x3d003
testq %rsi, %rsi
sete %dl
xorb $0x1, %cl
orb %dl, %cl
jne 0xd499
movq %rsi, %rdi
movq %rax, %rsi
jmp 0xc920
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpen2
extern zipFile ZEXPORT zipOpen2(const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def) {
    if (pzlib_filefunc32_def != NULL)
    {
        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
        fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
        return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
    }
    else
        return zipOpen3(pathname, append, globalcomment, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rcx, %rcx
je 0xde2d
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xce70
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0xc880
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc880
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpen2_64
extern zipFile ZEXPORT zipOpen2_64(const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def) {
    if (pzlib_filefunc_def != NULL)
    {
        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
        zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
        zlib_filefunc64_32_def_fill.ztell32_file = NULL;
        zlib_filefunc64_32_def_fill.zseek32_file = NULL;
        return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
    }
    else
        return zipOpen3(pathname, append, globalcomment, NULL);
}

// Assembly:
testq %rcx, %rcx
je 0xde81
subq $0x58, %rsp
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movq %rsp, %rcx
movaps %xmm3, 0x30(%rcx)
movaps %xmm2, 0x20(%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rcx)
callq 0xc880
addq $0x58, %rsp
retq
xorl %ecx, %ecx
jmp 0xc880
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zip64local_putValue_inmemory
local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte) {
    unsigned char* buf=(unsigned char*)dest;
    int n;
    for (n = 0; n < nbByte; n++) {
        buf[n] = (unsigned char)(x & 0xff);
        x >>= 8;
    }

    if (x != 0)
    {     /* data overflow - hack for ZIP64 */
       for (n = 0; n < nbByte; n++)
       {
          buf[n] = 0xff;
       }
    }
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0xe608
movb %sil, (%rdi,%rax)
shrq $0x8, %rsi
incq %rax
jmp 0xe5f6
testq %rsi, %rsi
je 0xe61d
xorl %eax, %eax
cmpq %rax, %rdx
je 0xe61d
movb $-0x1, (%rdi,%rax)
incq %rax
jmp 0xe60f
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: add_data_in_datablock
local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) {
    linkedlist_datablock_internal* ldi;
    const unsigned char* from_copy;

    if (ll==NULL)
        return ZIP_INTERNALERROR;

    if (ll->last_block == NULL)
    {
        ll->first_block = ll->last_block = allocate_new_datablock();
        if (ll->first_block == NULL)
            return ZIP_INTERNALERROR;
    }

    ldi = ll->last_block;
    from_copy = (const unsigned char*)buf;

    while (len>0)
    {
        uInt copy_this;
        uInt i;
        unsigned char* to_copy;

        if (ldi->avail_in_this_block==0)
        {
            ldi->next_datablock = allocate_new_datablock();
            if (ldi->next_datablock == NULL)
                return ZIP_INTERNALERROR;
            ldi = ldi->next_datablock ;
            ll->last_block = ldi;
        }

        if (ldi->avail_in_this_block < len)
            copy_this = (uInt)ldi->avail_in_this_block;
        else
            copy_this = (uInt)len;

        to_copy = &(ldi->data[ldi->filled_in_this_block]);

        for (i=0;i<copy_this;i++)
            *(to_copy+i)=*(from_copy+i);

        ldi->filled_in_this_block += copy_this;
        ldi->avail_in_this_block -= copy_this;
        from_copy += copy_this ;
        len -= copy_this;
    }
    return ZIP_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq $-0x68
popq %rbx
testq %rdi, %rdi
je 0xf096
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %r13
testq %r13, %r13
jne 0xf08f
callq 0xf8b3
movq %rax, %r13
movq %rax, 0x8(%r12)
movq %rax, (%r12)
testq %rax, %rax
jne 0xf08f
jmp 0xf096
movq 0x8(%r13), %rcx
testq %rcx, %rcx
jne 0xf057
callq 0xf8b3
movq %rax, (%r13)
testq %rax, %rax
je 0xf096
movq %rax, 0x8(%r12)
movq 0x8(%rax), %rcx
movq %rax, %r13
cmpq %r14, %rcx
cmovaeq %r14, %rcx
movq 0x10(%r13), %rax
addq %r13, %rax
addq $0x20, %rax
movl %ecx, %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xf07f
movb (%r15,%rsi), %dil
movb %dil, (%rax,%rsi)
incq %rsi
jmp 0xf06d
movl %ecx, %eax
addq %rax, 0x10(%r13)
subq %rax, 0x8(%r13)
addq %rax, %r15
subq %rax, %r14
testq %r14, %r14
jne 0xf034
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zip64local_putValue
local int zip64local_putValue(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte) {
    unsigned char buf[8];
    int n;
    for (n = 0; n < nbByte; n++)
    {
        buf[n] = (unsigned char)(x & 0xff);
        x >>= 8;
    }
    if (x != 0)
      {     /* data overflow - hack for ZIP64 (X Roche) */
      for (n = 0; n < nbByte; n++)
        {
          buf[n] = 0xff;
        }
      }

    if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,(uLong)nbByte)!=(uLong)nbByte)
        return ZIP_ERRNO;
    else
        return ZIP_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rax
xorl %r8d, %r8d
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
cmpq %r8, %rdi
je 0xf0ca
movb %dl, 0x8(%rsp,%r8)
shrq $0x8, %rdx
incq %r8
jmp 0xf0b7
testq %rdx, %rdx
je 0xf0e0
xorl %edx, %edx
cmpq %rdx, %rdi
je 0xf0e0
movb $-0x1, 0x8(%rsp,%rdx)
incq %rdx
jmp 0xf0d1
movq 0x38(%rax), %rdi
movl %ecx, %ebx
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq *0x10(%rax)
xorl %ecx, %ecx
cmpq %rbx, %rax
setne %cl
negl %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipRemoveExtraInfoBlock
extern int ZEXPORT zipRemoveExtraInfoBlock(char* pData, int* dataLen, short sHeader) {
  char* p = pData;
  int size = 0;
  char* pNewHeader;
  char* pTmp;
  short header;
  short dataSize;

  int retVal = ZIP_OK;

  if(pData == NULL || dataLen == NULL || *dataLen < 4)
    return ZIP_PARAMERROR;

  pNewHeader = (char*)ALLOC((unsigned)*dataLen);
  pTmp = pNewHeader;

  while(p < (pData + *dataLen))
  {
    header = *(short*)p;
    dataSize = *(((short*)p)+1);

    if( header == sHeader ) // Header found.
    {
      p += dataSize + 4; // skip it. do not copy to temp buffer
    }
    else
    {
      // Extra Info block should not be removed, So copy it to the temp buffer.
      memcpy(pTmp, p, dataSize + 4);
      p += dataSize + 4;
      size += dataSize + 4;
    }

  }

  if(size < *dataLen)
  {
    // clean old extra info block.
    memset(pData,0, *dataLen);

    // copy the new extra info block over the old
    if(size > 0)
      memcpy(pData, pNewHeader, size);

    // set the new extra info size
    *dataLen = size;

    retVal = ZIP_OK;
  }
  else
    retVal = ZIP_ERRNO;

  free(pNewHeader);

  return retVal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x66
popq %r13
jne 0xf5b4
movslq (%rsi), %r14
cmpq $0x4, %r14
jl 0xf5b4
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %r14, %rdi
callq 0xcab0
movq %rax, 0x8(%rsp)
movq %rbx, %r13
movq %r14, 0x20(%rsp)
addq %rbx, %r14
xorl %ebx, %ebx
movq %r13, 0x10(%rsp)
cmpq %r14, %r13
jae 0xf56f
movswq 0x2(%r13), %r12
cmpw %bp, (%r13)
jne 0xf549
addq $0x4, %r12
jmp 0xf56a
leal 0x4(%r12), %eax
movslq %eax, %r15
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xc960
addl %r12d, %ebx
addl $0x4, %ebx
movq %r15, %r12
addq %r12, %r13
jmp 0xf532
movq 0x20(%rsp), %rdx
cmpl %edx, %ebx
jge 0xf5a6
xorl %r13d, %r13d
movq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc690
testl %ebx, %ebx
jle 0xf59d
movl %ebx, %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0xc960
movq 0x18(%rsp), %rax
movl %ebx, (%rax)
jmp 0xf5aa
pushq $-0x1
popq %r13
movq 0x8(%rsp), %rdi
callq 0xc0d0
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zip64local_getLong
local int zip64local_getLong(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) {
    uLong x ;
    int i = 0;
    int err;

    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
    x = (uLong)i;

    if (err==ZIP_OK)
        err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
    x += ((uLong)i)<<8;

    if (err==ZIP_OK)
        err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
    x += ((uLong)i)<<16;

    if (err==ZIP_OK)
        err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
    x += ((uLong)i)<<24;

    if (err==ZIP_OK)
        *pX = x;
    else
        *pX = 0;
    return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc(%rsp), %r12
andl $0x0, (%r12)
movq %r12, %rdx
callq 0xf865
movl (%r12), %r12d
movslq %r12d, %r13
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0xf607
movl %r12d, %ebx
movl %r12d, %eax
jmp 0xf627
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xf865
movl (%r12), %ebx
testl %eax, %eax
je 0xf665
movl %ebx, %r12d
movl %ebx, %eax
movslq %ebx, %rcx
shlq $0x8, %rcx
addq %r13, %rcx
movslq %r12d, %rdx
shlq $0x10, %rdx
cltq
shlq $0x18, %rax
addq %rdx, %rax
addq %rcx, %rax
xorl %ecx, %ecx
testl %ebp, %ebp
cmoveq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xf865
movl (%r12), %r12d
testl %eax, %eax
jne 0xf602
leaq 0xc(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rdx, %r14
callq 0xf865
movl %eax, %ebp
movl (%r14), %eax
jmp 0xf627
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zip64local_getLong64
local int zip64local_getLong64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) {
  ZPOS64_T x;
  int i = 0;
  int err;

  err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x = (ZPOS64_T)i;

  if (err==ZIP_OK)
    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x += ((ZPOS64_T)i)<<8;

  if (err==ZIP_OK)
    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x += ((ZPOS64_T)i)<<16;

  if (err==ZIP_OK)
    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x += ((ZPOS64_T)i)<<24;

  if (err==ZIP_OK)
    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x += ((ZPOS64_T)i)<<32;

  if (err==ZIP_OK)
    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x += ((ZPOS64_T)i)<<40;

  if (err==ZIP_OK)
    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x += ((ZPOS64_T)i)<<48;

  if (err==ZIP_OK)
    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
  x += ((ZPOS64_T)i)<<56;

  if (err==ZIP_OK)
    *pX = x;
  else
    *pX = 0;

  return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
callq 0xf865
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0xf76b
leaq 0x4(%rsp), %rdx
movslq (%rdx), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xf865
testl %eax, %eax
jne 0xf76b
leaq 0x4(%rsp), %rdx
movslq (%rdx), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xf865
testl %eax, %eax
jne 0xf76b
movq %r13, 0x20(%rsp)
leaq 0x4(%rsp), %rdx
movslq (%rdx), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xf865
testl %eax, %eax
jne 0xf76b
movq %r13, 0x18(%rsp)
leaq 0x4(%rsp), %rdx
movslq (%rdx), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xf865
testl %eax, %eax
jne 0xf76b
movq %r13, 0x10(%rsp)
leaq 0x4(%rsp), %rdx
movslq (%rdx), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xf865
testl %eax, %eax
jne 0xf76b
movq %r13, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movl (%rdx), %r13d
movq %r15, %rdi
movq %r14, %rsi
callq 0xf865
testl %eax, %eax
je 0xf781
xorl %eax, %eax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4(%rsp), %rcx
movl (%rcx), %eax
movq %rcx, %r8
shlq $0x30, %rax
shlq $0x28, %r13
movq 0x8(%rsp), %rcx
shlq $0x20, %rcx
addq %r13, %rcx
addq %rax, %rcx
movq 0x10(%rsp), %rdx
shlq $0x18, %rdx
movq 0x18(%rsp), %rax
shlq $0x10, %rax
addq %rdx, %rax
movq 0x20(%rsp), %r13
shlq $0x8, %r13
addq %r12, %r13
addq %rax, %r13
addq %rcx, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %r8, %r14
movq %r8, %rdx
callq 0xf865
movl %eax, %ebp
movl (%r14), %ecx
shlq $0x38, %rcx
addq %r13, %rcx
xorl %eax, %eax
testl %ebp, %ebp
cmoveq %rcx, %rax
jmp 0xf76d
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zip64local_getByte
local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int* pi) {
    unsigned char c;
    int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
    if (err==1)
    {
        *pi = (int)c;
        return ZIP_OK;
    }
    else
    {
        if (ZERROR64(*pzlib_filefunc_def,filestream))
            return ZIP_ERRNO;
        else
            return ZIP_EOF;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
leaq 0xf(%rsp), %rdx
pushq $0x1
popq %rcx
callq *0x8(%rbx)
cmpl $0x1, %eax
jne 0xf897
movzbl 0xf(%rsp), %eax
movl %eax, (%r15)
xorl %eax, %eax
jmp 0xf8a9
movq 0x38(%rbx), %rdi
movq %r14, %rsi
callq *0x30(%rbx)
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: allocate_new_datablock
local linkedlist_datablock_internal* allocate_new_datablock(void) {
    linkedlist_datablock_internal* ldi;
    ldi = (linkedlist_datablock_internal*)
                 ALLOC(sizeof(linkedlist_datablock_internal));
    if (ldi!=NULL)
    {
        ldi->next_datablock = NULL ;
        ldi->filled_in_this_block = 0 ;
        ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
    }
    return ldi;
}

// Assembly:
pushq %rax
movl $0x1010, %edi           # imm = 0x1010
callq 0xcab0
testq %rax, %rax
je 0xf8d4
andq $0x0, (%rax)
andq $0x0, 0x10(%rax)
movq $0xff0, 0x8(%rax)       # imm = 0xFF0
popq %rcx
retq
nop