LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, 0x36d30(%rip)     # 0x3a110
movl %eax, 0x36d2e(%rip)     # 0x3a114
movl %eax, 0x37144(%rip)     # 0x3a530
movq $0x0, 0x38149(%rip) # 0x3b540
movl %eax, 0x380e3(%rip)     # 0x3b4e0
movl %eax, 0x380e1(%rip)     # 0x3b4e4
callq 0x3104
leaq 0x2164(%rip), %rdi      # 0x5573
callq 0x1070
movl $0x9, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x1fa4(%rip), %rdi      # 0x53cc
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
leaq 0x1f5b(%rip), %rdi      # 0x5395
callq 0x182f
movq %rax, 0x10(%rbx)
callq 0x1c9f
movq %rax, 0x20(%rbx)
callq 0x1bf9
movq %rax, 0x18(%rbx)
movq $0x19, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %edi
shrl $0x2, %edi
incl %edi
callq 0x12bb
movq %rax, %rbx
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testl %ebp, %ebp
je 0x34a1
leaq 0x10(%r14), %rsi
leaq 0x10(%rbx), %rdi
movl %ebp, %edx
shlq $0x3, %rdx
callq 0x10f0
jmp 0x34a3
xorl %ebp, %ebp
movl %ebp, %ecx
movq %r15, 0x10(%rbx,%rcx,8)
movl (%r14), %eax
shrl $0x2, %eax
cmpl %eax, %ebp
jae 0x34d5
leaq (%rbx,%rcx,8), %rdi
addq $0x18, %rdi
leaq (%r14,%rcx,8), %rsi
addq $0x10, %rsi
notl %ebp
addl %ebp, %eax
leaq 0x8(,%rax,8), %rdx
callq 0x10f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: 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 0x356a
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
cmovll %ecx, %r8d
testl %r8d, %r8d
je 0x3549
movl %r8d, %r8d
xorl %r9d, %r9d
movb 0x10(%rsi,%r9), %r10b
cmpb %r10b, 0x10(%rdx,%r9)
jne 0x354f
incq %r9
cmpq %r9, %r8
jne 0x3535
movl %eax, %esi
subl %ecx, %esi
jmp 0x355c
setge %cl
movzbl %cl, %ecx
leal -0x1(,%rcx,2), %esi
testl %esi, %esi
js 0x3574
je 0x359f
incq %r13
cmpq %r12, %r13
jne 0x3517
movl %r12d, %esi
callq 0x3462
jmp 0x357f
movl %r13d, %esi
callq 0x3462
movl %r13d, %r12d
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x3462
movq %rax, 0x18(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1a9a(%rip), %rdi      # 0x5040
leaq 0x1ded(%rip), %rsi      # 0x539a
leaq 0x1df9(%rip), %rdx      # 0x53ad
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0x16b9
leaq 0x2cc9c(%rip), %rdi     # 0x30270
movl $0x1, %esi
callq 0x1496
movq %rax, 0x37f5b(%rip)     # 0x3b540
testq %rax, %rax
je 0x365e
callq 0x153a
leaq 0x4b5a(%rip), %rax      # 0x8150
movq %rax, 0x5b53(%rip)      # 0x9150
callq 0x15be
movl $0x9, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x1db6(%rip), %rdi      # 0x53cc
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movl %ebp, 0x36ae7(%rip)     # 0x3a110
movl %ebp, 0x36ae5(%rip)     # 0x3a114
movl $0x1, 0x36ef7(%rip)     # 0x3a530
movq %rbx, %rdi
callq 0x333a
movq 0x37ef8(%rip), %rax     # 0x3b540
movq 0x20(%rax), %rdi
movq 0x10(%rbx), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x34e3
leaq 0x19db(%rip), %rdi      # 0x5040
leaq 0x1d4f(%rip), %rsi      # 0x53bb
leaq 0x2cbfd(%rip), %rdx     # 0x30270
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0x16b9
leaq 0x2ca4c(%rip), %r14     # 0x30270
movq %r14, %rdi
callq 0x1160
movq %rax, %rbx
callq 0x16b9
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
callq 0x15be
movq 0x5905(%rip), %rdi      # 0x9150
callq 0x1160
movq %rax, %r15
leaq 0x48f6(%rip), %r12      # 0x8150
leaq 0x1bbd(%rip), %rsi      # 0x541e
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1130
leaq 0x48e1(%rip), %r13      # 0x8159
movq %r13, 0x58d1(%rip)      # 0x9150
callq 0x3684
leaq 0x1bb0(%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, 0x58a8(%rip)      # 0x9150
callq 0x3684
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_O1/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 0x390b
cmpl $0xff, %ebx
jl 0x38fa
movl $0xff, %edi
movq %r14, %rsi
callq 0x10c0
addq $-0xff, %rbx
jmp 0x38d8
movl %ebx, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10c0
leaq 0x172e(%rip), %rdi      # 0x5040
leaq 0x1b3b(%rip), %rsi      # 0x5454
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: 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, 0x4625(%rip)      # 0x8140
je 0x3b61
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rdi), %rdx
movl (%rax), %ecx
shrl $0x2, %ecx
movl (%rdx), %edi
shrl $0x2, %edi
cmpl %ecx, %edi
movl %ecx, %r8d
cmovll %edi, %r8d
testl %r8d, %r8d
je 0x3b5a
movl %r8d, %r8d
xorl %r9d, %r9d
movb 0x10(%rdx,%r9), %r10b
cmpb %r10b, 0x10(%rax,%r9)
jne 0x3b66
incq %r9
cmpq %r9, %r8
jne 0x3b46
cmpl %edi, %ecx
setb %al
jmp 0x3b69
movq %rsi, %rbx
jmp 0x3b7e
setl %al
xorb $0x1, %al
movzbl %al, %r14d
movq 0x18(%rbx,%r14,8), %rdi
callq 0x3b10
movq %rax, 0x18(%rbx,%r14,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: 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 0x150c(%rip), %rdi      # 0x50b4
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x2c706(%rip)     # 0x302c0
je 0x3c2f
movq %rbx, (%rsp)
movq 0x10(%rbx), %r14
leaq 0x2c705(%rip), %r13     # 0x302d0
xorl %ebp, %ebp
movq (%r13), %rbx
movq 0x4568(%rip), %r15      # 0x8140
movl $0x3, %edi
callq 0x12bb
movq %rax, %r12
leaq 0x14c3(%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 0x3b10
movq %rax, %r14
incq %rbp
movl 0x2c6a2(%rip), %eax     # 0x302c0
addq $0x8, %r13
cmpq %rax, %rbp
jb 0x3bcd
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_O1/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 0x378dd(%rip), %rbx     # 0x3b530
leaq 0x145f(%rip), %rdi      # 0x50b9
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
xorl %edi, %edi
callq 0x12bb
movq %rax, %r14
leaq 0x1509(%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 0x14f0(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movq %r14, 0x18(%rbx)
cmpl $0x0, 0x54ac(%rip)      # 0x9158
jle 0x3d0a
xorl %r12d, %r12d
leaq 0x54a8(%rip), %r13      # 0x9160
leaq 0x1803(%rip), %r14      # 0x54c2
xorl %ebp, %ebp
movq (%r12,%r13), %r15
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
je 0x3cf7
movq %r15, %rdi
callq 0x182f
leaq 0x18cf8(%rip), %rcx     # 0x1c9e0
movq (%r12,%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x34e3
incq %rbp
movslq 0x5457(%rip), %rax      # 0x9158
addq $0x8, %r12
cmpq %rax, %rbp
jl 0x3cc1
leaq 0x17b6(%rip), %rdi      # 0x54c7
callq 0x182f
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 0x34e3
// File: /workspace/github_c_makefile_star2_O1/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 0x541e(%rip), %rax      # 0x9158
testq %rax, %rax
jle 0x3d60
shlq $0x3, %rax
xorl %ecx, %ecx
leaq 0x18c94(%rip), %rdx     # 0x1c9e0
movq (%rcx,%rdx), %rsi
cmpq $0x0, 0x8(%rsi)
je 0x3d62
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x3d4c
popq %rax
retq
leaq 0x53f7(%rip), %rax      # 0x9160
movq (%rcx,%rax), %rdx
leaq 0x12cc(%rip), %rdi      # 0x5040
leaq 0x1756(%rip), %rsi      # 0x54d1
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0xf9f5
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_O1/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:
movq $0x0, (%rdi)
movq (%rsi), %rax
movq %rax, 0x40(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
movq 0x38(%rsi), %rax
movq %rax, 0x38(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x50(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x48(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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        # 0xfab1
movq %rax, (%rdi)
leaq 0x97(%rip), %rax        # 0xfb04
movq %rax, 0x8(%rdi)
leaq 0xa2(%rip), %rax        # 0xfb1a
movq %rax, 0x10(%rdi)
leaq 0xad(%rip), %rax        # 0xfb30
movq %rax, 0x18(%rdi)
leaq 0xaa(%rip), %rax        # 0xfb38
movq %rax, 0x20(%rdi)
leaq 0xc7(%rip), %rax        # 0xfb60
movq %rax, 0x28(%rdi)
leaq 0xc4(%rip), %rax        # 0xfb68
movq %rax, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfac6
leaq 0x3053c(%rip), %rax     # 0x40000
jmp 0xfae9
testb $0x4, %dl
jne 0xfae2
shrl $0x3, %edx
xorl %eax, %eax
andl $0x1, %edx
leaq 0x3052d(%rip), %rcx     # 0x40007
cmovneq %rcx, %rax
movl %edx, %ecx
jmp 0xfae9
leaq 0x3051a(%rip), %rax     # 0x40003
testq %rsi, %rsi
sete %dl
xorb $0x1, %cl
orb %dl, %cl
jne 0xfb01
movq %rsi, %rdi
movq %rax, %rsi
jmp 0xcdc0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4e(%rip), %rax        # 0xfbc5
movq %rax, (%rdi)
leaq -0x7d(%rip), %rax       # 0xfb04
movq %rax, 0x8(%rdi)
leaq -0x72(%rip), %rax       # 0xfb1a
movq %rax, 0x10(%rdi)
leaq 0x81(%rip), %rax        # 0xfc18
movq %rax, 0x18(%rdi)
leaq 0x7e(%rip), %rax        # 0xfc20
movq %rax, 0x20(%rdi)
leaq -0x4d(%rip), %rax       # 0xfb60
movq %rax, 0x28(%rdi)
leaq -0x50(%rip), %rax       # 0xfb68
movq %rax, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfbda
leaq 0x30428(%rip), %rax     # 0x40000
jmp 0xfbfd
testb $0x4, %dl
jne 0xfbf6
shrl $0x3, %edx
xorl %eax, %eax
andl $0x1, %edx
leaq 0x30419(%rip), %rcx     # 0x40007
cmovneq %rcx, %rax
movl %edx, %ecx
jmp 0xfbfd
leaq 0x30406(%rip), %rax     # 0x40003
testq %rsi, %rsi
sete %dl
xorb $0x1, %cl
orb %dl, %cl
jne 0xfc15
movq %rsi, %rdi
movq %rax, %rsi
jmp 0xc8c0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10652
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xcdf0
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0xc820
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 0xc820
// File: /workspace/github_c_makefile_star2_O1/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 0x106a6
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 0xc820
addq $0x58, %rsp
retq
xorl %ecx, %ecx
jmp 0xc820
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffff98, %ebx       # imm = 0xFFFFFF98
testq %rdi, %rdi
je 0x11dc2
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
jne 0x11d20
movl $0x1010, %edi           # imm = 0x1010
callq 0xca50
testq %rax, %rax
je 0x11dbb
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x10(%rax)
movq $0xff0, 0x8(%rax)       # imm = 0xFF0
movq %rax, 0x8(%r14)
movq %rax, (%r14)
movq 0x8(%r14), %rbp
xorl %r13d, %r13d
testq %r15, %r15
je 0x11db7
cmpq $0x0, 0x8(%rbp)
je 0x11d3c
movq %rbp, %rax
jmp 0x11d62
movl $0x1010, %edi           # imm = 0x1010
callq 0xca50
testq %rax, %rax
je 0x11daf
movq %r13, (%rax)
movq %r13, 0x10(%rax)
movq $0xff0, 0x8(%rax)       # imm = 0xFF0
movq %rax, (%rbp)
movq %rax, 0x8(%r14)
movq 0x8(%rax), %rcx
cmpq %r15, %rcx
cmovaeq %r15, %rcx
testl %ecx, %ecx
je 0x11d90
movq 0x10(%rax), %rdx
addq %rax, %rdx
addq $0x20, %rdx
movl %ecx, %esi
xorl %edi, %edi
movb (%r12,%rdi), %r8b
movb %r8b, (%rdx,%rdi)
incq %rdi
cmpq %rdi, %rsi
jne 0x11d80
movl %ecx, %ecx
addq %rcx, 0x10(%rax)
subq %rcx, 0x8(%rax)
addq %rcx, %r12
subq %rcx, %r15
movb $0x1, %cl
movq %rax, %rbp
testb %cl, %cl
jne 0x11d27
jmp 0x11dc2
movq %rax, (%rbp)
xorl %ecx, %ecx
jmp 0x11da5
xorl %ebx, %ebx
jmp 0x11dc2
movq %rax, 0x8(%r14)
movq %rax, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffff9a, %r13d      # imm = 0xFFFFFF9A
jne 0x1258e
movslq (%rsi), %rbx
cmpq $0x4, %rbx
jl 0x1258e
movl %edx, %ebp
movq %rdi, %r15
movq %rsi, 0x18(%rsp)
movq %rbx, %rdi
callq 0xca50
movq %rax, 0x8(%rsp)
movq %rbx, 0x20(%rsp)
leaq (%r15,%rbx), %r14
xorl %ebx, %ebx
movq %r15, 0x10(%rsp)
movq %r15, %r13
movswq 0x2(%r13), %r12
cmpw %bp, (%r13)
jne 0x12520
addq $0x4, %r12
jmp 0x12541
leal 0x4(%r12), %eax
movslq %eax, %r15
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xc900
addl %r12d, %ebx
addl $0x4, %ebx
movq %r15, %r12
addq %r12, %r13
cmpq %r14, %r13
jb 0x1250e
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x20(%rsp), %rdx
cmpl %edx, %ebx
jge 0x12584
xorl %r13d, %r13d
movq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc640
testl %ebx, %ebx
jle 0x1257d
movl %ebx, %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0xc900
movq 0x18(%rsp), %rax
movl %ebx, (%rax)
movq 0x8(%rsp), %rdi
callq 0xc0c0
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_O1/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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movq %r12, %rdx
callq 0x12831
movslq (%r12), %r12
testl %eax, %eax
jne 0x125e1
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
movslq 0x4(%rsp), %r13
testl %eax, %eax
jne 0x125fa
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
movslq 0x4(%rsp), %rbp
testl %eax, %eax
jne 0x12613
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
shlq $0x8, %r13
addq %r12, %r13
shlq $0x10, %rbp
movslq 0x4(%rsp), %rcx
shlq $0x18, %rcx
addq %rbp, %rcx
addq %r13, %rcx
xorl %edx, %edx
testl %eax, %eax
cmoveq %rcx, %rdx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movq %r12, %rdx
callq 0x12831
movslq (%r12), %rcx
movq %rcx, 0x18(%rsp)
testl %eax, %eax
je 0x12686
xorl %eax, %eax
jmp 0x1269b
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
testl %eax, %eax
sete %al
movslq 0x4(%rsp), %r13
testb %al, %al
je 0x126bb
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
testl %eax, %eax
sete %al
jmp 0x126bd
xorl %eax, %eax
movslq 0x4(%rsp), %rcx
movq %rcx, 0x10(%rsp)
testb %al, %al
je 0x126e2
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
testl %eax, %eax
sete %al
jmp 0x126e4
xorl %eax, %eax
movslq 0x4(%rsp), %rbx
testb %al, %al
je 0x12704
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
testl %eax, %eax
sete %al
jmp 0x12706
xorl %eax, %eax
movslq 0x4(%rsp), %r12
testb %al, %al
je 0x12726
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
testl %eax, %eax
sete %al
jmp 0x12728
xorl %eax, %eax
movl 0x4(%rsp), %ebp
testb %al, %al
movq %r14, 0x8(%rsp)
je 0x1274c
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12831
testl %eax, %eax
sete %cl
jmp 0x1274e
xorl %ecx, %ecx
movl 0x4(%rsp), %r14d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x1276e
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x12831
shlq $0x8, %r13
addq 0x18(%rsp), %r13
movq 0x10(%rsp), %rcx
shlq $0x10, %rcx
shlq $0x18, %rbx
addq %rcx, %rbx
addq %r13, %rbx
shlq $0x20, %r12
shlq $0x28, %rbp
addq %r12, %rbp
shlq $0x30, %r14
addq %rbp, %r14
addq %rbx, %r14
movl 0x4(%rsp), %ecx
shlq $0x38, %rcx
addq %r14, %rcx
xorl %edx, %edx
testl %eax, %eax
cmoveq %rcx, %rdx
movq 0x20(%rsp), %rcx
movq %rdx, (%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ecx
callq *0x8(%rbx)
cmpl $0x1, %eax
jne 0x12865
movzbl 0xf(%rsp), %eax
movl %eax, (%r15)
xorl %eax, %eax
jmp 0x12877
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.c
// Function: tmpfileplus_f
FILE *tmpfileplus_f(const char *dir, const char *prefix, char *pathnamebuf, size_t pathsize, int keep)
{
	char *tmpbuf = NULL;
	FILE *fp;

	/* If no buffer provided, do the normal way */
	if (!pathnamebuf || (int)pathsize <= 0) {
		return tmpfileplus(dir, prefix, NULL, keep);
	}
	/* Call with a temporary buffer */
	fp = tmpfileplus(dir, prefix, &tmpbuf, keep);
	if (fp && strlen(tmpbuf) > pathsize - 1) {
		/* Succeeded but not enough room in output buffer, so clean up and return an error */
		pathnamebuf[0] = 0;
		fclose(fp);
		if (keep) remove(tmpbuf);
		free(tmpbuf);
		errno = E2BIG;
		return NULL;
	}
	/* Copy name into buffer */
	strcpy(pathnamebuf, tmpbuf);
	free(tmpbuf);

	return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r12
movq $0x0, (%rsp)
testq %rdx, %rdx
setne %al
testl %r12d, %r12d
setg %cl
testb %cl, %al
jne 0x12bd2
xorl %edx, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc090
movq %rdx, %r14
movq %rsp, %rdx
movl %ebx, %ecx
callq 0xc090
movq %rax, %r15
testq %rax, %rax
je 0x12c2a
movq (%rsp), %rdi
callq 0xc480
decq %r12
cmpq %r12, %rax
jbe 0x12c2a
movb $0x0, (%r14)
movq %r15, %rdi
callq 0xc420
testl %ebx, %ebx
je 0x12c11
movq (%rsp), %rdi
callq 0xc190
movq (%rsp), %rdi
callq 0xc0c0
callq 0xc150
movl $0x7, (%rax)
xorl %r15d, %r15d
jmp 0x12c41
movq (%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc230
movq %rbx, %rdi
callq 0xc0c0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/third_party/md5/md5.c
// Function: MD5_Update
void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
{
	MD5_u32plus saved_lo;
	unsigned long used, available;

	saved_lo = ctx->lo;
	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
		ctx->hi++;
	ctx->hi += size >> 29;

	used = saved_lo & 0x3f;

	if (used) {
		available = 64 - used;

		if (size < available) {
			memcpy(&ctx->buffer[used], data, size);
			return;
		}

		memcpy(&ctx->buffer[used], data, available);
		data = (const unsigned char *)data + available;
		size -= available;
		body(ctx, ctx->buffer, 64);
	}

	if (size >= 64) {
		data = body(ctx, data, size & ~(unsigned long)0x3f);
		size &= 0x3f;
	}

	memcpy(ctx->buffer, data, size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
leal (%rdx,%rax), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movl %ecx, (%rdi)
cmpl %eax, %ecx
jae 0x12c87
incl 0x4(%r14)
movq %rdx, %rcx
shrq $0x1d, %rcx
addl %ecx, 0x4(%r14)
andq $0x3f, %rax
je 0x12cb6
movl $0x40, %r12d
subq %rax, %r12
movq %rdx, %r15
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
subq %r12, %r15
jae 0x12cbb
movq %rbx, %rsi
jmp 0x12d09
movq %rdx, %r15
jmp 0x12cdd
leaq 0x18(%r14), %r13
movq %rbx, %rsi
movq %r12, %rdx
callq 0xc900
addq %r12, %rbx
movl $0x40, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x12d17
cmpq $0x40, %r15
jb 0x12cfc
movq %r15, %rdx
andq $-0x40, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12d17
movq %rax, %rbx
andl $0x3f, %r15d
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc900
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/app.c
// Function: lxw_app_new
lxw_app *
lxw_app_new(void)
{
    lxw_app *app = calloc(1, sizeof(lxw_app));
    GOTO_LABEL_ON_MEM_ERROR(app, mem_error);

    app->heading_pairs = calloc(1, sizeof(struct lxw_heading_pairs));
    GOTO_LABEL_ON_MEM_ERROR(app->heading_pairs, mem_error);
    STAILQ_INIT(app->heading_pairs);

    app->part_names = calloc(1, sizeof(struct lxw_part_names));
    GOTO_LABEL_ON_MEM_ERROR(app->part_names, mem_error);
    STAILQ_INIT(app->part_names);

    return app;

mem_error:
    lxw_app_free(app);
    return NULL;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0xc7f0
movq %rax, %rbx
testq %rax, %rax
je 0x136fb
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x13702
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x13709
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
movl $0x1f, %edi
jmp 0x1370e
movl $0x22, %edi
jmp 0x1370e
movl $0x26, %edi
movq %rbx, %rsi
callq 0xd120
xorl %ebx, %ebx
jmp 0x136f6
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/app.c
// Function: lxw_app_free
void
lxw_app_free(lxw_app *app)
{
    lxw_heading_pair *heading_pair;
    lxw_part_name *part_name;

    if (!app)
        return;

    /* Free the lists in the App object. */
    if (app->heading_pairs) {
        while (!STAILQ_EMPTY(app->heading_pairs)) {
            heading_pair = STAILQ_FIRST(app->heading_pairs);
            STAILQ_REMOVE_HEAD(app->heading_pairs, list_pointers);
            free(heading_pair->key);
            free(heading_pair->value);
            free(heading_pair);
        }
        free(app->heading_pairs);
    }

    if (app->part_names) {
        while (!STAILQ_EMPTY(app->part_names)) {
            part_name = STAILQ_FIRST(app->part_names);
            STAILQ_REMOVE_HEAD(app->part_names, list_pointers);
            free(part_name->name);
            free(part_name);
        }
        free(app->part_names);
    }

    free(app);
}

// Assembly:
testq %rdi, %rdi
je 0x137b6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x1375c
jmp 0x1376d
movq 0x10(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x13743
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0c0
movq 0x8(%r14), %rdi
callq 0xc0c0
movq %r14, %rdi
callq 0xc0c0
movq 0x8(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x13733
callq 0xc0c0
cmpq $0x0, 0x10(%rbx)
jne 0x13796
jmp 0x137a7
movq 0x8(%r14), %rax
movq %rax, (%rdi)
testq %rax, %rax
jne 0x13786
movq %rdi, 0x8(%rdi)
movq (%r14), %rdi
callq 0xc0c0
movq %r14, %rdi
callq 0xc0c0
movq 0x10(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x13776
callq 0xc0c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/app.c
// Function: lxw_app_add_part_name
void
lxw_app_add_part_name(lxw_app *self, const char *name)
{
    lxw_part_name *part_name;

    if (!name)
        return;

    part_name = calloc(1, sizeof(lxw_part_name));
    GOTO_LABEL_ON_MEM_ERROR(part_name, mem_error);

    part_name->name = lxw_strdup(name);
    GOTO_LABEL_ON_MEM_ERROR(part_name->name, mem_error);

    STAILQ_INSERT_TAIL(self->part_names, part_name, list_pointers);
    self->num_part_names++;

    return;

mem_error:
    if (part_name) {
        free(part_name->name);
        free(part_name);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x13c9c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
testq %rax, %rax
je 0x13c9d
movq %rax, %r14
movq %r15, %rdi
callq 0xcce0
movq %rax, (%r14)
testq %rax, %rax
je 0x13ca4
movq %r14, %rax
addq $0x8, %rax
movq $0x0, 0x8(%r14)
movq 0x10(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r14, (%rcx)
movq 0x10(%rbx), %rcx
movq %rax, 0x8(%rcx)
incl 0x24(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0xd19d
jmp 0x13c97
xorl %edi, %edi
testq %r14, %r14
sete %dil
movq %r14, %rsi
callq 0xd14e
jmp 0x13c97
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/app.c
// Function: lxw_app_add_heading_pair
void
lxw_app_add_heading_pair(lxw_app *self, const char *key, const char *value)
{
    lxw_heading_pair *heading_pair;

    if (!key || !value)
        return;

    heading_pair = calloc(1, sizeof(lxw_heading_pair));
    GOTO_LABEL_ON_MEM_ERROR(heading_pair, mem_error);

    heading_pair->key = lxw_strdup(key);
    GOTO_LABEL_ON_MEM_ERROR(heading_pair->key, mem_error);

    heading_pair->value = lxw_strdup(value);
    GOTO_LABEL_ON_MEM_ERROR(heading_pair->value, mem_error);

    STAILQ_INSERT_TAIL(self->heading_pairs, heading_pair, list_pointers);
    self->num_heading_pairs++;

    return;

mem_error:
    if (heading_pair) {
        free(heading_pair->key);
        free(heading_pair->value);
        free(heading_pair);
    }
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x13d40
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0xc7f0
testq %rax, %rax
je 0x13d41
movq %rax, %r14
movq %r12, %rdi
callq 0xcce0
movq %rax, (%r14)
testq %rax, %rax
je 0x13d48
movq %r15, %rdi
callq 0xcce0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x13d4f
movq %r14, %rax
addq $0x10, %rax
movq $0x0, 0x10(%r14)
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r14, (%rcx)
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
incl 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xd216
jmp 0x13d35
movl $0x1ae, %esi            # imm = 0x1AE
jmp 0x13d54
movl $0x1b1, %esi            # imm = 0x1B1
xorl %edx, %edx
testq %r14, %r14
sete %dl
movq %r14, %rdi
callq 0xd1c1
jmp 0x13d35
nop
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_series_free
STATIC void
_chart_series_free(lxw_chart_series *series)
{
    if (!series)
        return;

    free(series->title.name);
    free(series->line);
    free(series->fill);
    free(series->pattern);
    free(series->label_num_format);
    free(series->label_line);
    free(series->label_fill);
    free(series->label_pattern);

    _chart_free_font(series->label_font);

    if (series->marker) {
        free(series->marker->line);
        free(series->marker->fill);
        free(series->marker->pattern);
        free(series->marker);
    }

    _chart_free_range(series->categories);
    _chart_free_range(series->values);
    _chart_free_range(series->title.range);
    _chart_free_points(series);
    _chart_free_data_labels(series);

    if (series->x_error_bars) {
        free(series->x_error_bars->line);
        free(series->x_error_bars);
    }

    if (series->y_error_bars) {
        free(series->y_error_bars->line);
        free(series->y_error_bars);
    }

    free(series->trendline_line);
    free(series->trendline_name);

    free(series);
}

// Assembly:
testq %rdi, %rdi
je 0x14122
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xc0c0
movq 0x60(%rbx), %rdi
callq 0xc0c0
movq 0x68(%rbx), %rdi
callq 0xc0c0
movq 0x70(%rbx), %rdi
callq 0xc0c0
movq 0xa0(%rbx), %rdi
callq 0xc0c0
movq 0xb0(%rbx), %rdi
callq 0xc0c0
movq 0xb8(%rbx), %rdi
callq 0xc0c0
movq 0xc0(%rbx), %rdi
callq 0xc0c0
movq 0xa8(%rbx), %rdi
callq 0x14123
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x14095
movq 0x8(%rax), %rdi
callq 0xc0c0
movq 0x78(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0xc0c0
movq 0x78(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0xc0c0
movq 0x78(%rbx), %rdi
callq 0xc0c0
movq (%rbx), %rdi
callq 0x1413e
movq 0x8(%rbx), %rdi
callq 0x1413e
movq 0x30(%rbx), %rdi
callq 0x1413e
movq %rbx, %rdi
callq 0x15b0d
movq %rbx, %rdi
callq 0x15d67
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x140e0
movq 0x10(%rax), %rdi
callq 0xc0c0
movq 0xc8(%rbx), %rdi
callq 0xc0c0
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0x14101
movq 0x10(%rax), %rdi
callq 0xc0c0
movq 0xd0(%rbx), %rdi
callq 0xc0c0
movq 0x100(%rbx), %rdi
callq 0xc0c0
movq 0xf8(%rbx), %rdi
callq 0xc0c0
movq %rbx, %rdi
popq %rbx
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_free_range
STATIC void
_chart_free_range(lxw_series_range *range)
{
    struct lxw_series_data_point *data_point;

    if (!range)
        return;

    if (range->data_cache) {
        while (!STAILQ_EMPTY(range->data_cache)) {
            data_point = STAILQ_FIRST(range->data_cache);
            free(data_point->string);
            STAILQ_REMOVE_HEAD(range->data_cache, list_pointers);

            free(data_point);
        }
        free(range->data_cache);
    }

    free(range->formula);
    free(range->sheetname);
    free(range);
}

// Assembly:
testq %rdi, %rdi
je 0x141ac
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x1417b
jmp 0x1418c
movq 0x10(%r14), %rdi
callq 0xc0c0
movq 0x20(%rbx), %rax
movq (%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
jne 0x14173
movq %rax, 0x8(%rax)
movq %r14, %rdi
callq 0xc0c0
movq 0x20(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
jne 0x14153
callq 0xc0c0
movq (%rbx), %rdi
callq 0xc0c0
movq 0x8(%rbx), %rdi
callq 0xc0c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc0c0
retq
// File: /workspace/github_c_makefile_star2_O1/Paxa[P]fast_excel/libxlsxwriter/src/chart.c
// Function: chart_init_data_cache
STATIC lxw_error
_chart_init_data_cache(lxw_series_range *range)
{
    /* Initialize the series range data cache. */
    range->data_cache = calloc(1, sizeof(struct lxw_series_data_points));
    RETURN_ON_MEM_ERROR(range->data_cache, LXW_ERROR_MEMORY_MALLOC_FAILED);
    STAILQ_INIT(range->data_cache);

    return LXW_NO_ERROR;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0xc7f0
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x146ea
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
xorl %eax, %eax
popq %rbx
retq
callq 0xd25b
movl $0x1, %eax
jmp 0x146e8