LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_compress_mem_to_heap
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
    tdefl_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_len)
        return MZ_FALSE;
    else
        *pOut_len = 0;
    out_buf.m_expandable = MZ_TRUE;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return NULL;
    *pOut_len = out_buf.m_size;
    return out_buf.m_pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
testq %rdx, %rdx
je 0x76ee
movl %ecx, %r8d
movq %rdx, %rbx
movq $0x0, (%rdx)
leaq -0x30(%rbp), %rcx
movl $0x1, 0x18(%rcx)
leaq 0x1f(%rip), %rdx        # 0x76f7
callq 0x7608
testl %eax, %eax
je 0x76ee
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movq -0x20(%rbp), %rax
jmp 0x76f0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_output_buffer_putter(void const*, int, void*)
static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
{
    tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
    size_t new_size = p->m_size + len;
    if (new_size > p->m_capacity)
    {
        size_t new_capacity = p->m_capacity;
        mz_uint8 *pNew_buf;
        if (!p->m_expandable)
            return MZ_FALSE;
        do
        {
            new_capacity = MZ_MAX(128U, new_capacity << 1U);
        } while (new_size > new_capacity);
        pNew_buf = (mz_uint8 *)MZ_REALLOC(p->m_pBuf, new_capacity);
        if (!pNew_buf)
            return MZ_FALSE;
        p->m_pBuf = pNew_buf;
        p->m_capacity = new_capacity;
    }
    memcpy((mz_uint8 *)p->m_pBuf + p->m_size, pBuf, len);
    p->m_size = new_size;
    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %rax
movslq %esi, %r14
movq (%rdx), %r15
addq %r14, %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
jbe 0x775f
xorl %r13d, %r13d
cmpl $0x0, 0x18(%rbx)
je 0x777a
movq %rax, -0x30(%rbp)
movl $0x80, %eax
addq %r12, %r12
cmpq $0x81, %r12
cmovbq %rax, %r12
cmpq %r12, %r15
ja 0x772f
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x33e0
testq %rax, %rax
je 0x777a
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq -0x30(%rbp), %rax
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x31e0
movq %r15, (%rbx)
movl $0x1, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_compress_mem_to_mem
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
{
    tdefl_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_buf)
        return 0;
    out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
    out_buf.m_capacity = out_buf_len;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return 0;
    return out_buf.m_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
testq %rdi, %rdi
je 0x77d2
leaq -0x20(%rbp), %rax
movq %rdi, 0x10(%rax)
movq %rsi, 0x8(%rax)
leaq -0xc0(%rip), %r9        # 0x76f7
movq %rdx, %rdi
movq %rcx, %rsi
movq %r9, %rdx
movq %rax, %rcx
callq 0x7608
testl %eax, %eax
je 0x77d2
movq -0x20(%rbp), %rax
jmp 0x77d4
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: tinfl_decompress_mem_to_heap
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
    tinfl_decompressor decomp;
    void *pBuf = NULL, *pNew_buf;
    size_t src_buf_ofs = 0, out_buf_capacity = 0;
    *pOut_len = 0;
    tinfl_init(&decomp);
    for (;;)
    {
        size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, &dst_buf_size,
                                               (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
        if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        src_buf_ofs += src_buf_size;
        *pOut_len += dst_buf_size;
        if (status == TINFL_STATUS_DONE)
            break;
        new_out_buf_capacity = out_buf_capacity * 2;
        if (new_out_buf_capacity < 128)
            new_out_buf_capacity = 128;
        pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
        if (!pNew_buf)
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        pBuf = pNew_buf;
        out_buf_capacity = new_out_buf_capacity;
    }
    return pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b28, %rsp           # imm = 0x2B28
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq $0x0, (%rdx)
leaq -0x2b48(%rbp), %rax
movl $0x0, (%rax)
andl $-0x7, %r15d
orl $0x4, %r15d
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %edx, %edx
movl %r15d, -0x2c(%rbp)
movq -0x50(%rbp), %rax
subq %r12, %rax
movq %rax, -0x40(%rbp)
movq (%r14), %r8
movq %rdx, %rbx
movq %rdx, %rax
subq %r8, %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
leaq (%rax,%r12), %rsi
addq %r13, %r8
testq %r13, %r13
cmoveq %r13, %r8
movl %r15d, (%rsp)
leaq -0x2b48(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r13, %rcx
leaq -0x38(%rbp), %r9
callq 0x4425
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
je 0x7b73
movq %r13, %rdi
callq 0x32d0
movq $0x0, (%r14)
movl $0x1, %ecx
jmp 0x7bb9
addq -0x40(%rbp), %r12
movq -0x38(%rbp), %rcx
addq %rcx, (%r14)
testl %eax, %eax
je 0x7bb4
leaq (%rbx,%rbx), %r15
cmpq $0x81, %r15
movl $0x80, %eax
cmovbq %rax, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x33e0
testq %rax, %rax
je 0x7bc6
xorl %ecx, %ecx
movq %rax, %r13
movq %r15, %rdx
movl -0x2c(%rbp), %r15d
jmp 0x7bbc
movl $0x4, %ecx
movq %rbx, %rdx
testl %ecx, %ecx
je 0x7b06
jmp 0x7bcc
movl -0x2c(%rbp), %r15d
jmp 0x7b5d
cmpl $0x4, %ecx
je 0x7bd4
xorl %r13d, %r13d
movq %r13, %rax
addq $0x2b28, %rsp           # imm = 0x2B28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: tinfl_decompress_mem_to_callback
int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
    int result = 0;
    tinfl_decompressor decomp;
    mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
    size_t in_buf_ofs = 0, dict_ofs = 0;
    if (!pDict)
        return TINFL_STATUS_FAILED;
    tinfl_init(&decomp);
    for (;;)
    {
        size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
                                               (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
        in_buf_ofs += in_buf_size;
        if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
            break;
        if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
        {
            result = (status == TINFL_STATUS_DONE);
            break;
        }
        dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
    }
    MZ_FREE(pDict);
    *pIn_buf_size = in_buf_ofs;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b48, %rsp           # imm = 0x2B48
movl %r8d, %ebx
movq %rcx, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, -0x70(%rbp)
movl $0x8000, %edi           # imm = 0x8000
callq 0x3320
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x7d52
leaq -0x2b68(%rbp), %rax
movl $0x0, (%rax)
andl $-0x7, %ebx
movq $0x0, -0x38(%rbp)
xorl %r12d, %r12d
xorl %r15d, %r15d
movl %ebx, -0x2c(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
subq %r12, %rax
movq %rax, -0x58(%rbp)
movl $0x8000, %eax           # imm = 0x8000
subq %r15, %rax
movq %rax, -0x50(%rbp)
movq -0x70(%rbp), %rax
leaq (%rax,%r12), %rsi
movq -0x40(%rbp), %rcx
leaq (%rcx,%r15), %r14
movl %ebx, (%rsp)
leaq -0x2b68(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %r14, %r8
leaq -0x50(%rbp), %r9
callq 0x4425
movl %eax, %r13d
addq -0x58(%rbp), %r12
movq -0x50(%rbp), %rbx
testq %rbx, %rbx
je 0x7d0d
movq %r14, %rdi
movl %ebx, %esi
movq -0x68(%rbp), %rdx
callq *-0x60(%rbp)
testl %eax, %eax
je 0x7d2f
cmpl $0x2, %r13d
jne 0x7d23
addl %r15d, %ebx
andl $0x7fff, %ebx           # imm = 0x7FFF
movb $0x1, %al
movq %rbx, %r15
jmp 0x7d31
xorl %eax, %eax
testl %r13d, %r13d
sete %al
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl -0x2c(%rbp), %ebx
testb %al, %al
jne 0x7ca9
movq -0x40(%rbp), %rdi
callq 0x32d0
movq -0x48(%rbp), %rax
movq %r12, (%rax)
movq -0x38(%rbp), %rax
jmp 0x7d57
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x2b48, %rsp           # imm = 0x2B48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: tinfl_decompressor_alloc
tinfl_decompressor *tinfl_decompressor_alloc()
{
    tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor));
    if (pDecomp)
        tinfl_init(pDecomp);
    return pDecomp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2af8, %edi           # imm = 0x2AF8
callq 0x3320
testq %rax, %rax
je 0x7d82
movl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_end_internal(mz_zip_archive*, int)
static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
{
    mz_bool status = MZ_TRUE;

    if (!pZip)
        return MZ_FALSE;

    if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
    {
        if (set_last_error)
            pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER;

        return MZ_FALSE;
    }

    if (pZip->m_pState)
    {
        mz_zip_internal_state *pState = pZip->m_pState;
        pZip->m_pState = NULL;

        mz_zip_array_clear(pZip, &pState->m_central_dir);
        mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
        mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);

#ifndef MINIZ_NO_STDIO
        if (pState->m_pFile)
        {
            if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
            {
                if (MZ_FCLOSE(pState->m_pFile) == EOF)
                {
                    if (set_last_error)
                        pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED;
                    status = MZ_FALSE;
                }
            }
            pState->m_pFile = NULL;
        }
#endif /* #ifndef MINIZ_NO_STDIO */

        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
    }
    pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x7eb1
movl %esi, %r12d
movq %rdi, %rbx
movq 0x68(%rdi), %r14
testq %r14, %r14
je 0x7ea5
cmpq $0x0, 0x28(%rbx)
je 0x7ea5
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x7ea5
cmpl $0x1, 0x14(%rbx)
jne 0x7ea5
movq $0x0, 0x68(%rbx)
movq 0x40(%rbx), %rdi
movq (%r14), %rsi
callq *%rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq 0x40(%rbx), %rdi
movq 0x20(%r14), %rsi
callq *0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movq 0x40(%rbx), %rdi
movq 0x40(%r14), %rsi
callq *0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movq 0x70(%r14), %rdi
movl $0x1, %r15d
testq %rdi, %rdi
je 0x7e92
cmpl $0x4, 0x18(%rbx)
jne 0x7e8a
callq 0x3250
cmpl $-0x1, %eax
jne 0x7e8a
xorl %r15d, %r15d
testl %r12d, %r12d
je 0x7e8a
movl $0x15, 0x1c(%rbx)
movq $0x0, 0x70(%r14)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq *0x30(%rbx)
movl $0x0, 0x14(%rbx)
jmp 0x7eb1
testl %r12d, %r12d
je 0x7eb1
movl $0x18, 0x1c(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_init
mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags)
{
    if ((!pZip) || (!pZip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

    if (!mz_zip_reader_init_internal(pZip, flags))
        return MZ_FALSE;

    pZip->m_zip_type = MZ_ZIP_TYPE_USER;
    pZip->m_archive_size = size;

    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7f27
movq %rdi, %r14
cmpq $0x0, 0x48(%rdi)
je 0x7f1a
movl %edx, %r15d
movq %rsi, %r12
movq %r14, %rdi
movl %edx, %esi
callq 0x7f32
testl %eax, %eax
je 0x7f27
movl $0x1, 0x18(%r14)
movq %r12, (%r14)
movq %r14, %rdi
movl %r15d, %esi
callq 0x801b
movl $0x1, %ebx
testl %eax, %eax
jne 0x7f27
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x7dc3
jmp 0x7f27
testq %r14, %r14
je 0x7f27
movl $0x18, 0x1c(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_init_internal(mz_zip_archive*, unsigned int)
static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)
{
    (void)flags;
    if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

    if (!pZip->m_pAlloc)
        pZip->m_pAlloc = miniz_def_alloc_func;
    if (!pZip->m_pFree)
        pZip->m_pFree = miniz_def_free_func;
    if (!pZip->m_pRealloc)
        pZip->m_pRealloc = miniz_def_realloc_func;

    pZip->m_archive_size = 0;
    pZip->m_central_directory_file_ofs = 0;
    pZip->m_total_files = 0;
    pZip->m_last_error = MZ_ZIP_NO_ERROR;

    if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);

    memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
    pZip->m_pState->m_init_flags = flags;
    pZip->m_pState->m_zip64 = MZ_FALSE;
    pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE;

    pZip->m_zip_mode = MZ_ZIP_MODE_READING;

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x7f60
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
jne 0x7f54
cmpl $0x0, 0x14(%rbx)
je 0x7f6e
testq %rbx, %rbx
je 0x7f60
movl $0x18, 0x1c(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r14d
cmpq $0x0, 0x28(%rbx)
jne 0x7f83
leaq -0x47d3(%rip), %rax     # 0x37ac
movq %rax, 0x28(%rbx)
cmpq $0x0, 0x30(%rbx)
jne 0x7f95
leaq -0x47d4(%rip), %rax     # 0x37bd
movq %rax, 0x30(%rbx)
cmpq $0x0, 0x38(%rbx)
jne 0x7fa7
leaq -0x47d9(%rip), %rax     # 0x37ca
movq %rax, 0x38(%rbx)
xorl %r15d, %r15d
movl %r15d, 0x1c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl %r15d, 0x10(%rbx)
movq 0x40(%rbx), %rdi
movl $0x1, %esi
movl $0x98, %edx
callq *0x28(%rbx)
movq %rax, 0x68(%rbx)
testq %rax, %rax
je 0x800f
movl $0x98, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3160
movq 0x68(%rbx), %rax
movl $0x1, %r15d
movl %r15d, 0x18(%rax)
movl $0x4, %ecx
movl %ecx, 0x38(%rax)
movl %ecx, 0x58(%rax)
movl %r14d, 0x60(%rax)
movq $0x0, 0x64(%rax)
movl %r15d, 0x14(%rbx)
jmp 0x7f60
movl $0x10, 0x1c(%rbx)
jmp 0x7f60
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_init_mem
mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)
{
    if (!pMem)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

    if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);

    if (!mz_zip_reader_init_internal(pZip, flags))
        return MZ_FALSE;

    pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY;
    pZip->m_archive_size = size;
    pZip->m_pRead = mz_zip_mem_read_func;
    pZip->m_pIO_opaque = pZip;
    pZip->m_pNeeds_keepalive = NULL;

#ifdef __cplusplus
    pZip->m_pState->m_pMem = const_cast<void *>(pMem);
#else
    pZip->m_pState->m_pMem = (void *)pMem;
#endif

    pZip->m_pState->m_mem_size = size;

    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x8612
movq %rdx, %r15
cmpq $0x15, %rdx
ja 0x8623
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x8691
movl $0x8, 0x1c(%rbx)
jmp 0x8691
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x8691
movl $0x18, 0x1c(%rbx)
jmp 0x8691
movl %ecx, %r14d
movq %rsi, %r12
movq %rbx, %rdi
movl %ecx, %esi
callq 0x7f32
testl %eax, %eax
je 0x868e
movl $0x2, 0x18(%rbx)
movq %r15, (%rbx)
leaq 0x55(%rip), %rax        # 0x869d
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
movq $0x0, 0x58(%rbx)
movq 0x68(%rbx), %rax
movq %r12, 0x80(%rax)
movq %r15, 0x88(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x801b
movl $0x1, %r14d
testl %eax, %eax
jne 0x8691
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7dc3
jmp 0x8691
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_init_file_v2
mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)
{
    mz_uint64 file_size;
    MZ_FILE *pFile;

    if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

    pFile = MZ_FOPEN(pFilename, "rb");
    if (!pFile)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);

    file_size = archive_size;
    if (!file_size)
    {
        if (MZ_FSEEK64(pFile, 0, SEEK_END))
        {
            MZ_FCLOSE(pFile);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
        }

        file_size = MZ_FTELL64(pFile);
    }

    /* TODO: Better sanity check archive_size and the # of actual remaining bytes */

    if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
    {
	MZ_FCLOSE(pFile);
        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
    }

    if (!mz_zip_reader_init_internal(pZip, flags))
    {
        MZ_FCLOSE(pFile);
        return MZ_FALSE;
    }

    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
    pZip->m_pRead = mz_zip_file_read_func;
    pZip->m_pIO_opaque = pZip;
    pZip->m_pState->m_pFile = pFile;
    pZip->m_archive_size = file_size;
    pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;

    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x871c
movq %r8, %r12
leaq -0x1(%r8), %rax
cmpq $0x14, %rax
ja 0x872d
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x8774
movl $0x18, 0x1c(%rbx)
jmp 0x8774
movl %edx, %r14d
leaq 0xeb02(%rip), %rax      # 0x17239
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3280
testq %rax, %rax
je 0x876a
movq %rax, %r13
testq %r12, %r12
je 0x87de
cmpq $0x15, %r12
ja 0x8786
movq %r13, %rdi
callq 0x3250
movl $0x8, 0x1c(%rbx)
jmp 0x8771
movl $0x11, 0x1c(%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7f32
testl %eax, %eax
je 0x8808
movl $0x4, 0x18(%rbx)
leaq 0x82(%rip), %rax        # 0x8825
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
movq 0x68(%rbx), %rax
movq %r13, 0x70(%rax)
movq %r12, (%rbx)
movq %r15, 0x78(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x801b
movl $0x1, %r12d
testl %eax, %eax
jne 0x8774
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7dc3
jmp 0x8774
xorl %r12d, %r12d
movq %r13, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x33f0
testl %eax, %eax
je 0x8815
movq %r13, %rdi
callq 0x3250
movl $0x16, 0x1c(%rbx)
jmp 0x8774
movq %r13, %rdi
callq 0x3250
jmp 0x8771
movq %r13, %rdi
callq 0x3370
movq %rax, %r12
jmp 0x8753
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_file_read_func(void*, unsigned long, void*, unsigned long)
static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
{
    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
    mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);

    file_ofs += pZip->m_pState->m_file_archive_start_ofs;

    if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
        return 0;

    return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x68(%rdi), %rax
movq 0x70(%rax), %rdi
callq 0x3370
movq 0x68(%r15), %rcx
addq 0x78(%rcx), %r12
js 0x886a
cmpq %r12, %rax
je 0x8875
movq 0x70(%rcx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x33f0
testl %eax, %eax
je 0x8875
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x68(%r15), %rax
movq 0x70(%rax), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_init_cfile
mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags)
{
    mz_uint64 cur_file_ofs;

    if ((!pZip) || (!pFile))
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);

    cur_file_ofs = MZ_FTELL64(pFile);

    if (!archive_size)
    {
        if (MZ_FSEEK64(pFile, 0, SEEK_END))
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);

        archive_size = MZ_FTELL64(pFile) - cur_file_ofs;

        if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
            return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
    }

    if (!mz_zip_reader_init_internal(pZip, flags))
        return MZ_FALSE;

    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
    pZip->m_pRead = mz_zip_file_read_func;

    pZip->m_pIO_opaque = pZip;
    pZip->m_pState->m_pFile = pFile;
    pZip->m_archive_size = archive_size;
    pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs;

    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdi, %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x892c
movq %rdx, %r13
movq %rsi, %r15
movq %rsi, %rdi
callq 0x3370
movq %rax, -0x30(%rbp)
testq %r13, %r13
je 0x893d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7f32
testl %eax, %eax
je 0x895c
movl $0x5, 0x18(%rbx)
leaq -0xc8(%rip), %rax       # 0x8825
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
movq 0x68(%rbx), %rax
movq %r15, 0x70(%rax)
movq %r13, (%rbx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x78(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x801b
movl $0x1, %r12d
testl %eax, %eax
jne 0x8981
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7dc3
jmp 0x8981
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x8981
movl $0x11, 0x1c(%rbx)
jmp 0x8981
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x33f0
testl %eax, %eax
je 0x8961
movl $0x16, 0x1c(%rbx)
jmp 0x8981
xorl %r12d, %r12d
jmp 0x8981
movq %r15, %rdi
callq 0x3370
movq %rax, %r13
subq -0x30(%rbp), %r13
cmpq $0x15, %r13
ja 0x88d0
movl $0x8, 0x1c(%rbx)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_is_file_encrypted
mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index)
{
    mz_uint m_bit_flag;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return MZ_FALSE;
    }

    m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
    return (m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x89b8
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x89b8
cmpl %esi, 0x10(%rdi)
jbe 0x89b8
movq 0x20(%rax), %rcx
movl %esi, %edx
movl (%rcx,%rdx,4), %ecx
addq (%rax), %rcx
jmp 0x89ba
xorl %ecx, %ecx
xorl %eax, %eax
testq %rcx, %rcx
je 0x89ca
testb $0x41, 0x8(%rcx)
setne %al
jmp 0x89d6
testq %rdi, %rdi
je 0x89d6
movl $0x18, 0x1c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_is_file_supported
mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index)
{
    mz_uint bit_flag;
    mz_uint method;

    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return MZ_FALSE;
    }

    method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
    bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);

    if ((method != 0) && (method != MZ_DEFLATED))
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
        return MZ_FALSE;
    }

    if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION))
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
        return MZ_FALSE;
    }

    if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
        return MZ_FALSE;
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x89fd
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0x89fd
cmpl %esi, 0x10(%rdi)
jbe 0x89fd
movq 0x20(%rcx), %rax
movl %esi, %edx
movl (%rax,%rdx,4), %eax
addq (%rcx), %rax
jmp 0x89ff
xorl %eax, %eax
testq %rax, %rax
je 0x8a17
movzwl 0xa(%rax), %ecx
testl $0xfff7, %ecx           # imm = 0xFFF7
je 0x8a1e
movl $0x4, %ecx
jmp 0x8a2c
movl $0x18, %ecx
jmp 0x8a2c
movzwl 0x8(%rax), %edx
testb $0x41, %dl
je 0x8a38
movl $0x5, %ecx
testq %rdi, %rdi
je 0x8a34
movl %ecx, 0x1c(%rdi)
xorl %eax, %eax
popq %rbp
retq
andl $0x20, %edx
movl %edx, %eax
shrl $0x5, %eax
xorl $0x1, %eax
testq %rdi, %rdi
je 0x8a36
movl $0x6, %ecx
testl %edx, %edx
jne 0x8a31
jmp 0x8a36
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_is_file_a_directory
mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index)
{
    mz_uint filename_len, attribute_mapping_id, external_attr;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return MZ_FALSE;
    }

    filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
    if (filename_len)
    {
        if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
            return MZ_TRUE;
    }

    /* Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct. */
    /* Most/all zip writers (hopefully) set DOS file/directory attributes in the low 16-bits, so check for the DOS directory flag and ignore the source OS ID in the created by field. */
    /* FIXME: Remove this check? Is it necessary - we already check the filename. */
    attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8;
    (void)attribute_mapping_id;

    external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
    if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0)
    {
        return MZ_TRUE;
    }

    return MZ_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x8a78
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x8a78
cmpl %esi, 0x10(%rdi)
jbe 0x8a78
movq 0x20(%rax), %rcx
movl %esi, %edx
movl (%rcx,%rdx,4), %ecx
addq (%rax), %rcx
jmp 0x8a7a
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x8a9f
movzwl 0x1c(%rcx), %edx
testq %rdx, %rdx
je 0x8a94
movl $0x1, %eax
cmpb $0x2f, 0x2d(%rcx,%rdx)
je 0x8aad
movl 0x26(%rcx), %eax
shrl $0x4, %eax
andl $0x1, %eax
jmp 0x8aad
xorl %eax, %eax
testq %rdi, %rdi
je 0x8aad
movl $0x18, 0x1c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_extract_to_heap
void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
{
    mz_uint64 comp_size, uncomp_size, alloc_size;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    void *pBuf;

    if (pSize)
        *pSize = 0;

    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return NULL;
    }

    comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
    uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);

    alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? comp_size : uncomp_size;
    if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
    {
        mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
        return NULL;
    }

    if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
    {
        mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        return NULL;
    }

    if (!mz_zip_reader_extract_to_mem(pZip, file_index, pBuf, (size_t)alloc_size, flags))
    {
        pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
        return NULL;
    }

    if (pSize)
        *pSize = (size_t)alloc_size;
    return pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x9483
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x9483
cmpl %esi, 0x10(%rbx)
jbe 0x9483
movq 0x20(%rdi), %rax
movl %esi, %edx
movl (%rax,%rdx,4), %eax
addq (%rdi), %rax
jmp 0x9485
xorl %eax, %eax
testq %r14, %r14
je 0x9491
movq $0x0, (%r14)
testq %rax, %rax
je 0x94ee
movl %esi, -0x2c(%rbp)
xorl %edx, %edx
btl $0xa, %ecx
setae %dl
movl 0x14(%rax,%rdx,4), %r15d
movq 0x40(%rbx), %rdi
movl $0x1, %esi
movq %r15, %rdx
movl %ecx, %r12d
callq *0x28(%rbx)
testq %rax, %rax
je 0x94fc
movq %rax, %r13
movq $0x0, (%rsp)
movq %rbx, %rdi
movl -0x2c(%rbp), %esi
movq %rax, %rdx
movq %r15, %rcx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x8f79
testl %eax, %eax
je 0x950a
testq %r14, %r14
je 0x9517
movq %r15, (%r14)
jmp 0x9517
testq %rbx, %rbx
je 0x9514
movl $0x18, 0x1c(%rbx)
jmp 0x9514
testq %rbx, %rbx
je 0x9514
movl $0x10, 0x1c(%rbx)
jmp 0x9514
movq 0x40(%rbx), %rdi
movq %r13, %rsi
callq *0x30(%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_extract_file_to_heap
void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)
{
    mz_uint32 file_index;
    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
    {
        if (pSize)
            *pSize = 0;
        return MZ_FALSE;
    }
    return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %rbx
movq %rdi, %r15
leaq -0x1c(%rbp), %r8
xorl %edx, %edx
callq 0x8ad3
testl %eax, %eax
je 0x955e
movl -0x1c(%rbp), %esi
movq %r15, %rdi
movq %rbx, %rdx
movl %r14d, %ecx
callq 0x944b
jmp 0x956c
testq %rbx, %rbx
je 0x956a
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_extract_iter_free
mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState)
{
    int status;

    /* Argument sanity check */
    if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState))
        return MZ_FALSE;

    /* Was decompression completed and requested? */
    if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
    {
        /* Make sure the entire file was decompressed, and check its CRC. */
        if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size)
        {
            mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
            pState->status = TINFL_STATUS_FAILED;
        }
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
        else if (pState->file_crc32 != pState->file_stat.m_crc32)
        {
            mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
            pState->status = TINFL_STATUS_FAILED;
        }
#endif
    }

    /* Free buffers */
    if (!pState->pZip->m_pState->m_pMem)
        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf);
    if (pState->pWrite_buf)
        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf);

    /* Save status */
    status = pState->status;

    /* Free context */
    pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState);

    return status == TINFL_STATUS_DONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
testq %rdi, %rdi
je 0xa116
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xa116
movq 0x68(%rax), %rcx
testq %rcx, %rcx
je 0xa116
cmpl $0x0, 0xc(%rbx)
jne 0xa0d0
testb $0x4, 0x9(%rbx)
jne 0xa0d0
movq 0x38(%rbx), %rsi
movl $0xd, %edx
cmpq 0x78(%rbx), %rsi
jne 0xa0c6
movl 0x10(%rbx), %esi
movl $0xb, %edx
cmpl 0x68(%rbx), %esi
je 0xa0d0
movl %edx, 0x1c(%rax)
movl $0xffffffff, 0xc(%rbx)  # imm = 0xFFFFFFFF
cmpq $0x0, 0x80(%rcx)
jne 0xa0e8
movq 0x40(%rax), %rdi
movq 0x4a0(%rbx), %rsi
callq *0x30(%rax)
movq 0x4a8(%rbx), %rsi
testq %rsi, %rsi
je 0xa0fe
movq (%rbx), %rax
movq 0x40(%rax), %rdi
callq *0x30(%rax)
movq (%rbx), %rax
movq 0x40(%rax), %rdi
xorl %r14d, %r14d
cmpl $0x0, 0xc(%rbx)
sete %r14b
movq %rbx, %rsi
callq *0x30(%rax)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_extract_to_file
mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
{
    mz_bool status;
    mz_zip_archive_file_stat file_stat;
    MZ_FILE *pFile;

    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
        return MZ_FALSE;

    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);

    pFile = MZ_FOPEN(pDst_filename, "wb");
    if (!pFile)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);

    status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);

    if (MZ_FCLOSE(pFile) == EOF)
    {
        if (status)
            mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);

        status = MZ_FALSE;
    }

#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
    if (status)
        mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time);
#endif

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp            # imm = 0x478
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %r15
leaq -0x498(%rbp), %rdx
callq 0x9372
xorl %ebx, %ebx
testl %eax, %eax
je 0xa20c
cmpl $0x0, -0x44c(%rbp)
jne 0xa1f0
cmpl $0x0, -0x444(%rbp)
je 0xa1f0
leaq 0xd0c7(%rip), %rsi      # 0x1723c
movq %r14, -0x30(%rbp)
movq %r14, %rdi
callq 0x3280
testq %rax, %rax
je 0xa1ff
movq %rax, %r14
leaq 0x90(%rip), %rdx        # 0xa220
movq %r15, %rdi
movl %r13d, %esi
movq %rax, %rcx
movl %r12d, %r8d
callq 0x9577
movl %eax, %ebx
movq %r14, %rdi
callq 0x3250
cmpl $-0x1, %eax
movq -0x30(%rbp), %rdi
jne 0xa1cd
testl %ebx, %ebx
sete %al
testq %r15, %r15
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa1cd
movl $0x15, 0x1c(%r15)
testl %ebx, %ebx
je 0xa20c
movq -0x480(%rbp), %rax
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
movq %rax, (%rsi)
movq %rax, 0x8(%rsi)
callq 0x3140
jmp 0xa20c
testq %r15, %r15
je 0xa20c
movl $0x6, 0x1c(%r15)
jmp 0xa20c
testq %r15, %r15
je 0xa20c
movl $0x11, 0x1c(%r15)
movl %ebx, %eax
addq $0x478, %rsp            # imm = 0x478
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_extract_to_cfile
mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *pFile, mz_uint flags)
{
    mz_zip_archive_file_stat file_stat;

    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
        return MZ_FALSE;

    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);

    return mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x460, %rsp            # imm = 0x460
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
leaq -0x478(%rbp), %rdx
callq 0x9372
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0xa2f1
cmpl $0x0, -0x42c(%rbp)
jne 0xa2e4
cmpl $0x0, -0x424(%rbp)
je 0xa2e4
leaq -0xb1(%rip), %rdx       # 0xa220
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rcx
movl %ebx, %r8d
callq 0x9577
jmp 0xa2f1
testq %r15, %r15
je 0xa2f1
movl $0x6, 0x1c(%r15)
addq $0x460, %rsp            # imm = 0x460
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_validate_mem_archive
mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr)
{
    mz_bool success = MZ_TRUE;
    mz_zip_archive zip;
    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;

    if ((!pMem) || (!size))
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_PARAMETER;
        return MZ_FALSE;
    }

    mz_zip_zero_struct(&zip);

    if (!mz_zip_reader_init_mem(&zip, pMem, size, flags))
    {
        if (pErr)
            *pErr = zip.m_last_error;
        return MZ_FALSE;
    }

    if (!mz_zip_validate_archive(&zip, flags))
    {
        actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }

    if (!mz_zip_reader_end_internal(&zip, success))
    {
        if (!actual_err)
            actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }

    if (pErr)
        *pErr = actual_err;

    return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %rdx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0xad4b
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rdi
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movl %r14d, %ecx
callq 0x85e1
testl %eax, %eax
je 0xad5b
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0xab90
movl %eax, %r15d
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movl 0x1c(%r12), %r13d
movq %r12, %rdi
movl %r14d, %esi
callq 0x7dc3
testl %eax, %eax
cmovel %eax, %r14d
testq %rbx, %rbx
je 0xad6d
xorl %ecx, %ecx
testl %r15d, %r15d
cmovnel %ecx, %r13d
orl %r13d, %eax
je 0xad63
jmp 0xad6a
movl $0x18, %r13d
xorl %r14d, %r14d
testq %rbx, %rbx
jne 0xad6a
jmp 0xad6d
xorl %r14d, %r14d
testq %rbx, %rbx
je 0xad6d
movl -0x84(%rbp), %r13d
movl %r13d, (%rbx)
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_validate_file_archive
mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr)
{
    mz_bool success = MZ_TRUE;
    mz_zip_archive zip;
    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;

    if (!pFilename)
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_PARAMETER;
        return MZ_FALSE;
    }

    mz_zip_zero_struct(&zip);

    if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0))
    {
        if (pErr)
            *pErr = zip.m_last_error;
        return MZ_FALSE;
    }

    if (!mz_zip_validate_archive(&zip, flags))
    {
        actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }

    if (!mz_zip_reader_end_internal(&zip, success))
    {
        if (!actual_err)
            actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }

    if (pErr)
        *pErr = actual_err;

    return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
testq %rdi, %rdi
je 0xae24
movl %esi, %r15d
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rdi
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %r14d, %r14d
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x86eb
testl %eax, %eax
je 0xae34
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0xab90
movl %eax, %r15d
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movl 0x1c(%r12), %r13d
movq %r12, %rdi
movl %r14d, %esi
callq 0x7dc3
testl %eax, %eax
cmovel %eax, %r14d
testq %rbx, %rbx
je 0xae46
xorl %ecx, %ecx
testl %r15d, %r15d
cmovnel %ecx, %r13d
orl %r13d, %eax
je 0xae3c
jmp 0xae43
movl $0x18, %r13d
xorl %r14d, %r14d
testq %rbx, %rbx
jne 0xae43
jmp 0xae46
testq %rbx, %rbx
je 0xae46
xorl %r14d, %r14d
movl -0x84(%rbp), %r13d
movl %r13d, (%rbx)
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_init_heap_v2
mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags)
{
    pZip->m_pWrite = mz_zip_heap_write_func;
    pZip->m_pNeeds_keepalive = NULL;

    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
        pZip->m_pRead = mz_zip_mem_read_func;

    pZip->m_pIO_opaque = pZip;

    if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
        return MZ_FALSE;

    pZip->m_zip_type = MZ_ZIP_TYPE_HEAP;

    if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
    {
        if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size)))
        {
            mz_zip_writer_end_internal(pZip, MZ_FALSE);
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
        pZip->m_pState->m_mem_capacity = initial_allocation_size;
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x9e(%rip), %rax        # 0xb038
movq %rax, 0x50(%rdi)
movq $0x0, 0x58(%rdi)
testw %cx, %cx
jns 0xafb6
leaq -0x2915(%rip), %rax     # 0x869d
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0xae58
testl %eax, %eax
je 0xb00c
cmpq %r14, %r15
cmovaq %r15, %r14
movl $0x3, 0x18(%rbx)
movl $0x1, %r15d
testq %r14, %r14
je 0xb00f
movq 0x40(%rbx), %rdi
movl $0x1, %esi
movq %r14, %rdx
callq *0x28(%rbx)
movq 0x68(%rbx), %rcx
movq %rax, 0x80(%rcx)
testq %rax, %rax
je 0xb01d
movq %r14, 0x90(%rcx)
jmp 0xb00f
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb118
testq %rbx, %rbx
je 0xb00f
movl $0x10, 0x1c(%rbx)
jmp 0xb00f
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_heap_write_func(void*, unsigned long, void const*, unsigned long)
static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
{
    mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
    mz_zip_internal_state *pState = pZip->m_pState;
    mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size);

    if (!n)
        return 0;

    /* An allocation this big is likely to just fail on 32-bit systems, so don't even go there. */
    if ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF))
    {
        mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
        return 0;
    }

    if (new_size > pState->m_mem_capacity)
    {
        void *pNew_block;
        size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity);

        while (new_capacity < new_size)
            new_capacity *= 2;

        if (NULL == (pNew_block = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity)))
        {
            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
            return 0;
        }

        pState->m_pMem = pNew_block;
        pState->m_mem_capacity = new_capacity;
    }
    memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n);
    pState->m_mem_size = (size_t)new_size;
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x68(%rdi), %r14
leaq (%rcx,%rsi), %rax
movq 0x88(%r14), %r12
cmpq %r12, %rax
cmovaq %rax, %r12
testq %rcx, %rcx
je 0xb104
movq %rcx, %rbx
movq %rsi, %r15
movq 0x90(%r14), %rcx
cmpq %rcx, %r12
jbe 0xb0e6
movq %rdi, %r8
movq %rdx, -0x30(%rbp)
cmpq $0x41, %rcx
movl $0x40, %eax
cmovaeq %rcx, %rax
movq %rax, %r13
addq %rax, %rax
cmpq %r12, %r13
jb 0xb08e
movq 0x40(%r8), %rdi
movq 0x80(%r14), %rsi
movl $0x1, %edx
movq %r13, %rcx
movq %r8, -0x38(%rbp)
callq *0x38(%r8)
testq %rax, %rax
je 0xb0cd
movq %rax, 0x80(%r14)
movq %r13, 0x90(%r14)
movq -0x30(%rbp), %rdx
jmp 0xb0e1
movq -0x38(%rbp), %rcx
testq %rcx, %rcx
movq -0x30(%rbp), %rdx
je 0xb0e1
movl $0x10, 0x1c(%rcx)
testq %rax, %rax
je 0xb104
addq 0x80(%r14), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x31e0
movq %r12, 0x88(%r14)
jmp 0xb106
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq