LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: fseek_file_func
static long ZCALLBACK fseek_file_func(voidpf opaque, voidpf stream, uLong offset, int origin) {
    int fseek_origin=0;
    long ret;
    (void)opaque;
    switch (origin)
    {
    case ZLIB_FILEFUNC_SEEK_CUR :
        fseek_origin = SEEK_CUR;
        break;
    case ZLIB_FILEFUNC_SEEK_END :
        fseek_origin = SEEK_END;
        break;
    case ZLIB_FILEFUNC_SEEK_SET :
        fseek_origin = SEEK_SET;
        break;
    default: return -1;
    }
    ret = 0;
    if (fseek((FILE *)stream, (long)offset, fseek_origin) != 0)
        ret = -1;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0xd6e0
jmp 0xd6ba
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0xd6ce
jmp 0xd6c4
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0xd6d7
jmp 0xd6e9
movl $0x1, -0x28(%rbp)
jmp 0xd6f3
movl $0x2, -0x28(%rbp)
jmp 0xd6f3
movl $0x0, -0x28(%rbp)
jmp 0xd6f3
movq $-0x1, -0x8(%rbp)
jmp 0xd720
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0xcbe0
cmpl $0x0, %eax
je 0xd718
movq $-0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x6d(%rip), %rcx        # 0xd810
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq -0x1d1(%rip), %rcx      # 0xd5e0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq -0x1a0(%rip), %rcx      # 0xd620
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0xe1(%rip), %rcx        # 0xd8b0
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0x102(%rip), %rcx       # 0xd8e0
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq -0xbd(%rip), %rcx       # 0xd730
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq -0x9c(%rip), %rcx       # 0xd760
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xd84b
leaq 0x587bb(%rip), %rax     # 0x66000
movq %rax, -0x28(%rbp)
jmp 0xd87d
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd863
leaq 0x587a6(%rip), %rax     # 0x66003
movq %rax, -0x28(%rbp)
jmp 0xd87b
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd879
leaq 0x58792(%rip), %rax     # 0x66007
movq %rax, -0x28(%rbp)
jmp 0xd87b
jmp 0xd87d
cmpq $0x0, -0x10(%rbp)
je 0xd89c
cmpq $0x0, -0x28(%rbp)
je 0xd89c
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc940
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/ioapi.c
// Function: fseek64_file_func
static long ZCALLBACK fseek64_file_func(voidpf opaque, voidpf stream, ZPOS64_T offset, int origin) {
    int fseek_origin=0;
    long ret;
    (void)opaque;
    switch (origin)
    {
    case ZLIB_FILEFUNC_SEEK_CUR :
        fseek_origin = SEEK_CUR;
        break;
    case ZLIB_FILEFUNC_SEEK_END :
        fseek_origin = SEEK_END;
        break;
    case ZLIB_FILEFUNC_SEEK_SET :
        fseek_origin = SEEK_SET;
        break;
    default: return -1;
    }
    ret = 0;

    if(FSEEKO_FUNC((FILE *)stream, (z_off64_t)offset, fseek_origin) != 0)
                        ret = -1;

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0xd930
jmp 0xd90a
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0xd91e
jmp 0xd914
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0xd927
jmp 0xd939
movl $0x1, -0x28(%rbp)
jmp 0xd943
movl $0x2, -0x28(%rbp)
jmp 0xd943
movl $0x0, -0x28(%rbp)
jmp 0xd943
movq $-0x1, -0x8(%rbp)
jmp 0xd970
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0xcc00
cmpl $0x0, %eax
je 0xd968
movq $-0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe1e8
movq -0x28(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xcea0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0xc8a0
movq %rax, -0x8(%rbp)
jmp 0xe200
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xc8a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe26d
leaq -0x80(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x40, %edx
callq 0xc980
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0xc8a0
movq %rax, -0x8(%rbp)
jmp 0xe285
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xc8a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zip64local_TmzDateToDosDate
local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) {
    uLong year = (uLong)ptm->tm_year;
    if (year>=1980)
        year-=1980;
    else if (year>=80)
        year-=80;
    return
      (uLong) (((uLong)(ptm->tm_mday) + (32 * (uLong)(ptm->tm_mon+1)) + (512 * year)) << 16) |
        (((uLong)ptm->tm_sec/2) + (32 * (uLong)ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x7bc, -0x10(%rbp)     # imm = 0x7BC
jb 0xeb6e
movq -0x10(%rbp), %rax
subq $0x7bc, %rax            # imm = 0x7BC
movq %rax, -0x10(%rbp)
jmp 0xeb83
cmpq $0x50, -0x10(%rbp)
jb 0xeb81
movq -0x10(%rbp), %rax
subq $0x50, %rax
movq %rax, -0x10(%rbp)
jmp 0xeb83
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
shlq $0x10, %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shrq %rcx
movq -0x8(%rbp), %rdx
movslq 0x4(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq -0x8(%rbp), %rdx
movslq 0x8(%rdx), %rdx
shlq $0xb, %rdx
addq %rdx, %rcx
orq %rcx, %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xec34
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xebfe
cmpq $0x0, -0x10(%rbp)
je 0xec63
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xec61
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $-0x1, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xec42
jmp 0xec63
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpenNewFileInZip4
extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char* filename, const zip_fileinfo* zipfi,
                                        const void* extrafield_local, uInt size_extrafield_local,
                                        const void* extrafield_global, uInt size_extrafield_global,
                                        const char* comment, int method, int level, int raw,
                                        int windowBits,int memLevel, int strategy,
                                        const char* password, uLong crcForCrypting,
                                        uLong versionMadeBy, uLong flagBase) {
    return zipOpenNewFileInZip4_64(file, filename, zipfi,
                                   extrafield_local, size_extrafield_local,
                                   extrafield_global, size_extrafield_global,
                                   comment, method, level, raw,
                                   windowBits, memLevel, strategy,
                                   password, crcForCrypting, versionMadeBy, flagBase, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x68(%rbp), %rax
movq 0x60(%rbp), %rax
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movl 0x48(%rbp), %eax
movl 0x40(%rbp), %eax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movl %r8d, -0x4c(%rbp)
movq %r9, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl -0x4c(%rbp), %r8d
movq -0x58(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, -0x74(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movl 0x20(%rbp), %eax
movl %eax, -0x68(%rbp)
movl 0x28(%rbp), %eax
movl %eax, -0x64(%rbp)
movl 0x30(%rbp), %r13d
movl 0x38(%rbp), %r12d
movl 0x40(%rbp), %r15d
movl 0x48(%rbp), %r14d
movq 0x50(%rbp), %rbx
movq 0x58(%rbp), %r11
movq 0x60(%rbp), %r10
movq 0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
movl -0x74(%rbp), %eax
movl %eax, (%rsp)
movq -0x70(%rbp), %rax
movq %rax, 0x8(%rsp)
movl -0x68(%rbp), %eax
movl %eax, 0x10(%rsp)
movl -0x64(%rbp), %eax
movl %eax, 0x18(%rsp)
movq -0x60(%rbp), %rax
movl %r13d, 0x20(%rsp)
movl %r12d, 0x28(%rsp)
movl %r15d, 0x30(%rsp)
movl %r14d, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq %r11, 0x48(%rsp)
movq %r10, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
callq 0xc7a0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpenNewFileInZip3
extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char* filename, const zip_fileinfo* zipfi,
                                        const void* extrafield_local, uInt size_extrafield_local,
                                        const void* extrafield_global, uInt size_extrafield_global,
                                        const char* comment, int method, int level, int raw,
                                        int windowBits,int memLevel, int strategy,
                                        const char* password, uLong crcForCrypting) {
    return zipOpenNewFileInZip4_64(file, filename, zipfi,
                                   extrafield_local, size_extrafield_local,
                                   extrafield_global, size_extrafield_global,
                                   comment, method, level, raw,
                                   windowBits, memLevel, strategy,
                                   password, crcForCrypting, VERSIONMADEBY, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movl 0x48(%rbp), %eax
movl 0x40(%rbp), %eax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movl %r8d, -0x4c(%rbp)
movq %r9, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl -0x4c(%rbp), %r8d
movq -0x58(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl 0x20(%rbp), %r13d
movl 0x28(%rbp), %r12d
movl 0x30(%rbp), %r15d
movl 0x38(%rbp), %r14d
movl 0x40(%rbp), %ebx
movl 0x48(%rbp), %r11d
movq 0x50(%rbp), %r10
movq 0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
xorl %eax, %eax
movl -0x6c(%rbp), %eax
movl %eax, (%rsp)
movq -0x68(%rbp), %rax
movq %rax, 0x8(%rsp)
movq -0x60(%rbp), %rax
movl %r13d, 0x10(%rsp)
movl %r12d, 0x18(%rsp)
movl %r15d, 0x20(%rsp)
movl %r14d, 0x28(%rsp)
movl %ebx, 0x30(%rsp)
movl %r11d, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
callq 0xc7a0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpenNewFileInZip3_64
extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
                                         const void* extrafield_local, uInt size_extrafield_local,
                                         const void* extrafield_global, uInt size_extrafield_global,
                                         const char* comment, int method, int level, int raw,
                                         int windowBits,int memLevel, int strategy,
                                         const char* password, uLong crcForCrypting, int zip64) {
    return zipOpenNewFileInZip4_64(file, filename, zipfi,
                                   extrafield_local, size_extrafield_local,
                                   extrafield_global, size_extrafield_global,
                                   comment, method, level, raw,
                                   windowBits, memLevel, strategy,
                                   password, crcForCrypting, VERSIONMADEBY, 0, zip64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl 0x60(%rbp), %eax
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movl 0x48(%rbp), %eax
movl 0x40(%rbp), %eax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movl %r8d, -0x4c(%rbp)
movq %r9, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl -0x4c(%rbp), %r8d
movq -0x58(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl 0x20(%rbp), %eax
movl %eax, -0x60(%rbp)
movl 0x28(%rbp), %r13d
movl 0x30(%rbp), %r12d
movl 0x38(%rbp), %r15d
movl 0x40(%rbp), %r14d
movl 0x48(%rbp), %ebx
movq 0x50(%rbp), %r11
movq 0x58(%rbp), %r10
movl 0x60(%rbp), %eax
movl %eax, -0x5c(%rbp)
xorl %eax, %eax
movl -0x6c(%rbp), %eax
movl %eax, (%rsp)
movq -0x68(%rbp), %rax
movq %rax, 0x8(%rsp)
movl -0x60(%rbp), %eax
movl %eax, 0x10(%rsp)
movl -0x5c(%rbp), %eax
movl %r13d, 0x18(%rsp)
movl %r12d, 0x20(%rsp)
movl %r15d, 0x28(%rsp)
movl %r14d, 0x30(%rsp)
movl %ebx, 0x38(%rsp)
movq %r11, 0x40(%rsp)
movq %r10, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movl %eax, 0x60(%rsp)
callq 0xc7a0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpenNewFileInZip2
extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,
                                        const void* extrafield_local, uInt size_extrafield_local,
                                        const void* extrafield_global, uInt size_extrafield_global,
                                        const char* comment, int method, int level, int raw) {
    return zipOpenNewFileInZip4_64(file, filename, zipfi,
                                   extrafield_local, size_extrafield_local,
                                   extrafield_global, size_extrafield_global,
                                   comment, method, level, raw,
                                   -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
                                   NULL, 0, VERSIONMADEBY, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x3c(%rbp)
movq %r9, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %r8d
movq -0x48(%rbp), %r9
movl 0x10(%rbp), %r14d
movq 0x18(%rbp), %rbx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
xorl %r15d, %r15d
xorl %r15d, %r15d
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movl $0xfffffff1, 0x28(%rsp) # imm = 0xFFFFFFF1
movl $0x8, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
callq 0xc7a0
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpenNewFileInZip2_64
extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
                                           const void* extrafield_local, uInt size_extrafield_local,
                                           const void* extrafield_global, uInt size_extrafield_global,
                                           const char* comment, int method, int level, int raw, int zip64) {
    return zipOpenNewFileInZip4_64(file, filename, zipfi,
                                   extrafield_local, size_extrafield_local,
                                   extrafield_global, size_extrafield_global,
                                   comment, method, level, raw,
                                   -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
                                   NULL, 0, VERSIONMADEBY, 0, zip64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movl %r8d, -0x44(%rbp)
movq %r9, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl -0x44(%rbp), %r8d
movq -0x50(%rbp), %r9
movl 0x10(%rbp), %r15d
movq 0x18(%rbp), %r14
movl 0x20(%rbp), %ebx
movl 0x28(%rbp), %r11d
movl 0x30(%rbp), %r10d
movl 0x38(%rbp), %eax
xorl %r12d, %r12d
xorl %r12d, %r12d
movl %r15d, (%rsp)
movq %r14, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl $0xfffffff1, 0x28(%rsp) # imm = 0xFFFFFFF1
movl $0x8, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movl %eax, 0x60(%rsp)
callq 0xc7a0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zipOpenNewFileInZip
extern int ZEXPORT zipOpenNewFileInZip(zipFile file, const char* filename, const zip_fileinfo* zipfi,
                                       const void* extrafield_local, uInt size_extrafield_local,
                                       const void*extrafield_global, uInt size_extrafield_global,
                                       const char* comment, int method, int level) {
    return zipOpenNewFileInZip4_64(file, filename, zipfi,
                                   extrafield_local, size_extrafield_local,
                                   extrafield_global, size_extrafield_global,
                                   comment, method, level, 0,
                                   -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
                                   NULL, 0, VERSIONMADEBY, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq -0x40(%rbp), %r9
movl 0x10(%rbp), %ebx
movq 0x18(%rbp), %r11
movl 0x20(%rbp), %r10d
movl 0x28(%rbp), %eax
xorl %r14d, %r14d
xorl %r14d, %r14d
movl %ebx, (%rsp)
movq %r11, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movl $0xfffffff1, 0x28(%rsp) # imm = 0xFFFFFFF1
movl $0x8, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
callq 0xc7a0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: zip64FlushWriteBuffer
local int zip64FlushWriteBuffer(zip64_internal* zi) {
    int err=ZIP_OK;

    if (zi->ci.encrypt != 0)
    {
#ifndef NOCRYPT
        uInt i;
        int t;
        for (i=0;i<zi->ci.pos_in_buffered_data;i++)
            zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);
#endif
    }

    if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data)
      err = ZIP_ERRNO;

    zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;

#ifdef HAVE_BZIP2
    if(zi->ci.method == Z_BZIP2ED)
    {
      zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32;
      zi->ci.bstream.total_in_lo32 = 0;
      zi->ci.bstream.total_in_hi32 = 0;
    }
    else
#endif
    {
      zi->ci.totalUncompressedData += zi->ci.stream.total_in;
      zi->ci.stream.total_in = 0;
    }


    zi->ci.pos_in_buffered_data = 0;

    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10138(%rax)
je 0xf952
jmp 0xf952
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rsi
movq -0x8(%rbp), %rdx
addq $0x78, %rdx
addq $0xb0, %rdx
movq -0x8(%rbp), %rcx
movl 0xec(%rcx), %ecx
callq *%rax
movq -0x8(%rbp), %rcx
movl 0xec(%rcx), %ecx
cmpq %rcx, %rax
je 0xf99b
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0xec(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x10148(%rax), %rcx
movq %rcx, 0x10148(%rax)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x10150(%rax), %rcx
movq %rcx, 0x10150(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xec(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x10311
movq -0x20(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movslq -0x30(%rbp), %rax
movb %cl, -0x2c(%rbp,%rax)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x102de
cmpq $0x0, -0x20(%rbp)
je 0x1033d
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1033b
movslq -0x30(%rbp), %rax
movb $-0x1, -0x2c(%rbp,%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1031f
jmp 0x1033d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movslq -0x24(%rbp), %rcx
callq *%rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
je 0x1036d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10374
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: Write_Zip64EndOfCentralDirectoryLocator
local int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) {
  int err = ZIP_OK;
  ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset;

  err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);

  /*num disks*/
    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);

  /*relative offset*/
    if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */
      err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);

  /*total disks*/ /* Do not support spawning of disk so always say 1 here*/
    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);

    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x10160(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movl $0x7064b50, %edx        # imm = 0x7064B50
movl $0x4, %ecx
callq 0x102c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x107db
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x4, %ecx
callq 0x102c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x107fe
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x20(%rbp), %rdx
movl $0x8, %ecx
callq 0x102c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x10822
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movl $0x1, %edx
movl $0x4, %ecx
callq 0x102c0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: Write_GlobalComment
local int Write_GlobalComment(zip64_internal* zi, const char* global_comment) {
  int err = ZIP_OK;
  uInt size_global_comment = 0;

  if(global_comment != NULL)
    size_global_comment = (uInt)strlen(global_comment);

  err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);

  if (err == ZIP_OK && size_global_comment > 0)
  {
    if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)
      err = ZIP_ERRNO;
  }
  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10a41
movq -0x10(%rbp), %rdi
callq 0xc4e0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
movl $0x2, %ecx
callq 0x102c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x10a9d
cmpl $0x0, -0x18(%rbp)
jbe 0x10a9d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rsi
movq -0x10(%rbp), %rdx
movl -0x18(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
je 0x10a9b
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x10a9d
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x11430
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x11181
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x11430
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rax
shlq $0x8, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x111ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x11430
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rax
shlq $0x10, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x111d5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x11430
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rax
shlq $0x18, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x111f8
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x11203
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq -0x21(%rbp), %rdx
movl $0x1, %ecx
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x1147f
movzbl -0x21(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x114aa
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x114a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x114aa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1010, %edi           # imm = 0x1010
callq 0xcaf0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11500
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0xff0, 0x8(%rax)       # imm = 0xFF0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/minizip/zip.c
// Function: free_datablock
local void free_datablock(linkedlist_datablock_internal* ldi) {
    while (ldi!=NULL)
    {
        linkedlist_datablock_internal* ldinext = ldi->next_datablock;
        free(ldi);
        ldi = ldinext;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11541
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc0d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1151c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.c
// Function: getenv_save
static char *getenv_save(const char *varname, char *buf, size_t bufsize)
{
	char *ptr = getenv(varname);
	buf[0] = '\0';
	if (ptr)
	{
		strncpy(buf, ptr, bufsize-1);
		buf[bufsize-1] = '\0';
		return buf;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc050
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x1178e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
callq 0xc1a0
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11796
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x119c4
movq -0x28(%rbp), %rax
cmpl $0x0, %eax
jg 0x119e1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0xc0a0
movq %rax, -0x8(%rbp)
jmp 0x11a71
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %ecx
leaq -0x38(%rbp), %rdx
callq 0xc0a0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x11a53
movq -0x38(%rbp), %rdi
callq 0xc4e0
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x11a53
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0xc460
cmpl $0x0, -0x2c(%rbp)
je 0x11a35
movq -0x38(%rbp), %rdi
callq 0xc1c0
movq -0x38(%rbp), %rdi
callq 0xc0d0
callq 0xc180
movl $0x7, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x11a71
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc260
movq -0x38(%rbp), %rdi
callq 0xc0d0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Paxa[P]fast_excel/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.c
// Function: set_randpart
static char *set_randpart(char *s)
{
	size_t i;
	unsigned int r;
	static unsigned int seed;	/* NB static */

	if (seed == 0)
	{	/* First time set our seed using current time and clock */
		seed = ((unsigned)time(NULL)<<8) ^ (unsigned)clock();
	}
	srand(seed++);
	for (i = 0; i < strlen(s); i++)
	{
		r = rand() % NRANDCHARS;
		s[i] = (RANDCHARS)[r];
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x6c711(%rip)     # 0x7e1f4
jne 0x11b07
xorl %eax, %eax
movl %eax, %edi
callq 0xca30
shll $0x8, %eax
movl %eax, -0x18(%rbp)
callq 0xc430
movq %rax, %rcx
movl -0x18(%rbp), %eax
xorl %ecx, %eax
movl %eax, 0x6c6ed(%rip)     # 0x7e1f4
movl 0x6c6e7(%rip), %edi     # 0x7e1f4
movl %edi, %eax
addl $0x1, %eax
movl %eax, 0x6c6dc(%rip)     # 0x7e1f4
callq 0xc820
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc4e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x11b80
callq 0xd170
cltq
movl $0x3e, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x5452d(%rip), %rax     # 0x66091
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11b25
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq -0x18(%rbp), %rax
andq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
movq -0x8(%rbp), %rcx
movl %eax, (%rcx)
cmpl -0x1c(%rbp), %eax
jae 0x11c22
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rdx
shrq $0x1d, %rdx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %eax
andl $0x3f, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x11cc9
movl $0x40, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x11c7f
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc980
jmp 0x11d0a
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc980
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movl $0x40, %edx
callq 0x11d10
cmpq $0x40, -0x18(%rbp)
jb 0x11cf5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
andq $-0x40, %rdx
callq 0x11d10
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc980
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x30, %esi
callq 0xc870
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1301b
movq 0x69fff(%rip), %rax     # 0x7cff8
movq (%rax), %rdi
leaq 0x530cd(%rip), %rsi     # 0x660d0
leaq 0x530f1(%rip), %rdx     # 0x660fb
movl $0x1f, %ecx
movb $0x0, %al
callq 0xc8f0
jmp 0x1310e
jmp 0x1301d
movl $0x1, %edi
movl $0x10, %esi
callq 0xc870
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1306b
movq 0x69faf(%rip), %rax     # 0x7cff8
movq (%rax), %rdi
leaq 0x5307d(%rip), %rsi     # 0x660d0
leaq 0x530a1(%rip), %rdx     # 0x660fb
movl $0x22, %ecx
movb $0x0, %al
callq 0xc8f0
jmp 0x1310e
jmp 0x1306d
jmp 0x1306f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0xc870
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x130dd
movq 0x69f3a(%rip), %rax     # 0x7cff8
movq (%rax), %rdi
leaq 0x53008(%rip), %rsi     # 0x660d0
leaq 0x5302c(%rip), %rdx     # 0x660fb
movl $0x26, %ecx
movb $0x0, %al
callq 0xc8f0
jmp 0x1310e
jmp 0x130df
jmp 0x130e1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1311f
movq -0x10(%rbp), %rdi
callq 0xcd30
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)