LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0xac10
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 0x86e7
testl %eax, %eax
je 0xac1e
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0xa987
movl %eax, %r15d
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movl 0x1c(%r12), %r13d
movq %r12, %rdi
movl %r14d, %esi
callq 0x7ac9
testl %eax, %eax
cmovel %eax, %r14d
testq %rbx, %rbx
je 0xac30
xorl %ecx, %ecx
testl %r15d, %r15d
cmovnel %ecx, %r13d
orl %r13d, %eax
je 0xac26
jmp 0xac2d
xorl %r14d, %r14d
testq %rbx, %rbx
je 0xac30
pushq $0x18
popq %r13
jmp 0xac2d
testq %rbx, %rbx
je 0xac30
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_O2/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 0x92(%rip), %rax        # 0xae06
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
testw %cx, %cx
jns 0xad8d
leaq -0x26f0(%rip), %rax     # 0x8699
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0xac42
testl %eax, %eax
je 0xaddf
cmpq %r14, %r15
cmovaq %r15, %r14
movl $0x3, 0x18(%rbx)
pushq $0x1
popq %r15
testq %r14, %r14
je 0xadf8
movq 0x40(%rbx), %rdi
pushq $0x1
popq %rsi
movq %r14, %rdx
callq *0x28(%rbx)
movq 0x68(%rbx), %rcx
movq %rax, 0x80(%rcx)
testq %rax, %rax
je 0xade4
movq %r14, 0x90(%rcx)
jmp 0xadf8
xorl %r15d, %r15d
jmp 0xadf8
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xaed8
movl $0x10, 0x1c(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
cmpq %r15, %rax
cmovaq %rax, %r15
testq %rcx, %rcx
je 0xaec4
movq %rcx, %rbx
movq 0x90(%r14), %rcx
cmpq %rcx, %r15
jbe 0xae9d
movq %rdi, %r12
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
cmpq $0x41, %rcx
pushq $0x40
popq %rax
cmovaeq %rcx, %rax
movq %rax, %r13
addq %rax, %rax
cmpq %r15, %r13
jb 0xae5b
movq 0x40(%r12), %rdi
movq 0x80(%r14), %rsi
pushq $0x1
popq %rdx
movq %r13, %rcx
callq *0x38(%r12)
testq %rax, %rax
je 0xaebb
movq %rax, %rdi
movq %rax, 0x80(%r14)
movq %r13, 0x90(%r14)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rsi
jmp 0xaea4
movq 0x80(%r14), %rdi
addq %rsi, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x31f0
movq %r15, 0x88(%r14)
jmp 0xaec6
movl $0x10, 0x1c(%r12)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_end_internal(mz_zip_archive*, int)
static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
{
    mz_zip_internal_state *pState;
    mz_bool status = MZ_TRUE;

    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)))
    {
        if (set_last_error)
            mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return MZ_FALSE;
    }

    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)
                    mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
                status = MZ_FALSE;
            }
        }

        pState->m_pFile = NULL;
    }
#endif /* #ifndef MINIZ_NO_STDIO */

    if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem))
    {
        pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem);
        pState->m_pMem = NULL;
    }

    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 0xafe8
movl %esi, %r12d
movq %rdi, %rbx
movq 0x68(%rdi), %r14
testq %r14, %r14
je 0xafdc
cmpq $0x0, 0x28(%rbx)
je 0xafdc
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0xafdc
movl 0x14(%rbx), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0xafdc
andq $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
pushq $0x1
popq %r15
testq %rdi, %rdi
je 0xafa4
cmpl $0x4, 0x18(%rbx)
jne 0xaf9f
callq 0x3260
cmpl $-0x1, %eax
jne 0xaf9f
xorl %r15d, %r15d
testl %r12d, %r12d
je 0xaf9f
movl $0x15, 0x1c(%rbx)
andq $0x0, 0x70(%r14)
leaq -0x1a5(%rip), %rax      # 0xae06
cmpq %rax, 0x50(%rbx)
jne 0xafcc
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0xafcc
movq 0x40(%rbx), %rdi
callq *0x30(%rbx)
andq $0x0, 0x80(%r14)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq *0x30(%rbx)
andl $0x0, 0x14(%rbx)
jmp 0xafe8
testl %r12d, %r12d
je 0xafe8
movl $0x18, 0x1c(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_init_file_v2
mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags)
{
    MZ_FILE *pFile;

    pZip->m_pWrite = mz_zip_file_write_func;
    pZip->m_pNeeds_keepalive = NULL;

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

    pZip->m_pIO_opaque = pZip;

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

    if (NULL == (pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb")))
    {
        mz_zip_writer_end(pZip);
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
    }

    pZip->m_pState->m_pFile = pFile;
    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;

    if (size_to_reserve_at_beginning)
    {
        mz_uint64 cur_ofs = 0;
        char buf[4096];

        MZ_CLEAR_OBJ(buf);

        do
        {
            size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
            if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n)
            {
                mz_zip_writer_end(pZip);
                return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
            }
            cur_ofs += n;
            size_to_reserve_at_beginning -= n;
        } while (size_to_reserve_at_beginning);
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xf8(%rip), %rax        # 0xb12b
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
testw %r13w, %r13w
jns 0xb04d
leaq -0x2828(%rip), %rax     # 0x8821
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0xac42
xorl %r15d, %r15d
testl %eax, %eax
je 0xb116
testw %r13w, %r13w
leaq 0xb1a7(%rip), %rax      # 0x1621c
leaq 0xb1a3(%rip), %rsi      # 0x1621f
cmovnsq %rax, %rsi
movq %r12, %rdi
callq 0x3290
testq %rax, %rax
je 0xb0f3
movq 0x68(%rbx), %rcx
movq %rax, 0x70(%rcx)
movl $0x4, 0x18(%rbx)
pushq $0x1
popq %r15
testq %r14, %r14
je 0xb116
leaq -0x1030(%rbp), %r12
xorl %r13d, %r13d
movl $0x1000, %edx           # imm = 0x1000
movq %r12, %rdi
xorl %esi, %esi
callq 0x3180
movl $0x1000, %eax           # imm = 0x1000
cmpq %rax, %r14
movl $0x1000, %r15d          # imm = 0x1000
cmovbq %r14, %r15
movq 0x60(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq *0x50(%rbx)
cmpq %r15, %rax
jne 0xb104
addq %r15, %r13
subq %r15, %r14
jne 0xb0be
pushq $0x1
popq %r15
jmp 0xb116
movq %rbx, %rdi
callq 0xb1a1
movl $0x11, 0x1c(%rbx)
jmp 0xb116
movq %rbx, %rdi
callq 0xb1a1
movl $0x13, 0x1c(%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_file_write_func(void*, unsigned long, void const*, unsigned long)
static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const 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))))
    {
        mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
        return 0;
    }

    return MZ_FWRITE(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 0x3390
movq 0x68(%r15), %rcx
addq 0x78(%rcx), %r12
js 0xb170
cmpq %r12, %rax
je 0xb187
movq 0x70(%rcx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3410
testl %eax, %eax
je 0xb183
movl $0x16, 0x1c(%r15)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x68(%r15), %rcx
movq 0x70(%rcx), %rcx
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_init_cfile
mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags)
{
    pZip->m_pWrite = mz_zip_file_write_func;
    pZip->m_pNeeds_keepalive = NULL;

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

    pZip->m_pIO_opaque = pZip;

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

    pZip->m_pState->m_pFile = pFile;
    pZip->m_pState->m_file_archive_start_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x9c(%rip), %rax       # 0xb12b
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
testw %dx, %dx
jns 0xb1e0
leaq -0x29bb(%rip), %rax     # 0x8821
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xac42
testl %eax, %eax
je 0xb218
movq 0x68(%rbx), %rax
movq %r14, 0x70(%rax)
movq %r14, %rdi
callq 0x3390
movq 0x68(%rbx), %rcx
movq %rax, 0x78(%rcx)
movl $0x5, 0x18(%rbx)
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_write_zeros(mz_zip_archive*, unsigned long, unsigned int)
static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
{
    char buf[4096];
    memset(buf, 0, MZ_MIN(sizeof(buf), n));
    while (n)
    {
        mz_uint32 s = MZ_MIN(sizeof(buf), n);
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);

        cur_file_ofs += s;
        n -= s;
    }
    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1000, %eax           # imm = 0x1000
cmpl %eax, %edx
movl $0x1000, %edx           # imm = 0x1000
cmovbl %ebx, %edx
leaq -0x1030(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x3180
testl %ebx, %ebx
je 0xbfd9
movl $0x1000, %eax           # imm = 0x1000
cmpl %eax, %ebx
movl $0x1000, %r12d          # imm = 0x1000
cmovbl %ebx, %r12d
movq 0x60(%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *0x50(%r14)
cmpq %r12, %rax
jne 0xbfde
addq %r12, %r15
subl %r12d, %ebx
jmp 0xbfa6
pushq $0x1
popq %rax
jmp 0xbfe8
movl $0x13, 0x1c(%r14)
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_add_file
mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
{
    MZ_FILE *pSrc_file = NULL;
    mz_uint64 uncomp_size = 0;
    MZ_TIME_T file_modified_time;
    MZ_TIME_T *pFile_time = NULL;
    mz_bool status;

    memset(&file_modified_time, 0, sizeof(file_modified_time));

#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
    pFile_time = &file_modified_time;
    if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time))
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_STAT_FAILED);
#endif

    pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
    if (!pSrc_file)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);

    MZ_FSEEK64(pSrc_file, 0, SEEK_END);
    uncomp_size = MZ_FTELL64(pSrc_file);
    MZ_FSEEK64(pSrc_file, 0, SEEK_SET);

    status = mz_zip_writer_add_cfile(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags, NULL, 0, NULL, 0);

    MZ_FCLOSE(pSrc_file);

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, -0x48(%rbp)
movl %r8d, %r15d
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq -0xe0(%rbp), %rsi
movq %rdx, %rdi
callq 0x3430
testl %eax, %eax
je 0xcdc4
xorl %r15d, %r15d
testq %r14, %r14
je 0xce6b
movl $0x17, 0x1c(%r14)
jmp 0xce6b
movq %r14, -0x30(%rbp)
movl %r15d, %r14d
movq %r13, -0x38(%rbp)
movq %r12, -0x40(%rbp)
movq -0x48(%rbp), %r15
movq -0x88(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x9430(%rip), %rsi      # 0x16219
movq %rbx, %rdi
callq 0x3290
testq %rax, %rax
je 0xce58
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3410
movq %rbx, %rdi
callq 0x3390
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3410
movzwl %r14w, %eax
leaq -0x50(%rbp), %r8
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq -0x40(%rbp), %r9
pushq $0x0
pushq $0x0
pushq $0x0
pushq $0x0
pushq %r15
pushq %rax
callq 0xc436
addq $0x30, %rsp
movl %eax, %r15d
movq %rbx, %rdi
callq 0x3260
jmp 0xce6b
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0xce6b
movl $0x11, 0x1c(%rax)
movl %r15d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_finalize_heap_archive
mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize)
{
    if ((!ppBuf) || (!pSize))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

    *ppBuf = NULL;
    *pSize = 0;

    if ((!pZip) || (!pZip->m_pState))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

    if (pZip->m_pWrite != mz_zip_heap_write_func)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

    if (!mz_zip_writer_finalize_archive(pZip))
        return MZ_FALSE;

    *ppBuf = pZip->m_pState->m_pMem;
    *pSize = pZip->m_pState->m_mem_size;
    pZip->m_pState->m_pMem = NULL;
    pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0;

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
je 0xde8b
movq %rdx, %r15
movq %rsi, %r12
andq $0x0, (%rsi)
andq $0x0, (%rdx)
xorl %ebx, %ebx
testq %r14, %r14
je 0xde9a
cmpq $0x0, 0x68(%r14)
je 0xde92
leaq -0x303f(%rip), %rax     # 0xae06
cmpq %rax, 0x50(%r14)
jne 0xde92
movq %r14, %rdi
callq 0xda2f
testl %eax, %eax
je 0xde9a
movq 0x68(%r14), %rax
movq 0x80(%rax), %rax
movq %rax, (%r12)
movq 0x68(%r14), %rax
movq 0x88(%rax), %rcx
movq %rcx, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rax)
andq $0x0, 0x90(%rax)
pushq $0x1
popq %rbx
jmp 0xde9a
xorl %ebx, %ebx
testq %r14, %r14
je 0xde9a
movl $0x18, 0x1c(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_extract_archive_file_to_heap_v2
void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr)
{
    mz_uint32 file_index;
    mz_zip_archive zip_archive;
    void *p = NULL;

    if (pSize)
        *pSize = 0;

    if ((!pZip_filename) || (!pArchive_name))
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_PARAMETER;

        return NULL;
    }

    mz_zip_zero_struct(&zip_archive);
    if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
    {
        if (pErr)
            *pErr = zip_archive.m_last_error;

        return NULL;
    }

    if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, &file_index))
    {
        p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags);
    }

    mz_zip_reader_end_internal(&zip_archive, p != NULL);

    if (pErr)
        *pErr = zip_archive.m_last_error;

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %rbx
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rsi
testq %rcx, %rcx
je 0xe122
andq $0x0, (%r15)
testq %rsi, %rsi
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
je 0xe1a5
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, %edx
orl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x86e7
testl %eax, %eax
je 0xe1b2
leaq -0xa0(%rbp), %rdi
leaq -0x2c(%rbp), %r8
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x8aaf
testl %eax, %eax
je 0xe1c2
movl -0x2c(%rbp), %esi
leaq -0xa0(%rbp), %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x937c
movq %rax, %r14
jmp 0xe1c5
xorl %r14d, %r14d
testq %rbx, %rbx
je 0xe1e7
pushq $0x18
popq %rax
jmp 0xe1e5
testq %rbx, %rbx
je 0xe1f9
movl -0x84(%rbp), %eax
xorl %r14d, %r14d
jmp 0xe1e5
xorl %r14d, %r14d
xorl %esi, %esi
testq %r14, %r14
setne %sil
leaq -0xa0(%rbp), %rdi
callq 0x7ac9
testq %rbx, %rbx
je 0xe1e7
movl -0x84(%rbp), %eax
movl %eax, (%rbx)
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0xe1e7
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_reader_get_filename
mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
{
    mz_uint n;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        if (filename_buf_size)
            pFilename[0] = '\0';
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return 0;
    }
    n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
    if (filename_buf_size)
    {
        n = MZ_MIN(n, filename_buf_size - 1);
        memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
        pFilename[n] = '\0';
    }
    return n + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %ecx, %r14d
movq %rdx, %rbx
testq %rdi, %rdi
je 0xe3dc
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xe3dc
movl %esi, %eax
cmpl %esi, 0x10(%rdi)
jbe 0xe3dc
movq (%rcx), %rsi
testq %rsi, %rsi
je 0xe3dc
movq 0x20(%rcx), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
addq %rax, %rsi
movzwl 0x1c(%rsi), %eax
testl %r14d, %r14d
je 0xe3d8
decl %r14d
cmpl %eax, %r14d
cmovael %eax, %r14d
addq $0x2e, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x31f0
movb $0x0, (%rbx,%r14)
movl %r14d, %eax
incl %eax
jmp 0xe3f2
testl %r14d, %r14d
je 0xe3e4
movb $0x0, (%rbx)
xorl %eax, %eax
testq %rdi, %rdi
je 0xe3f2
movl $0x18, 0x1c(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_end
mz_bool mz_zip_end(mz_zip_archive *pZip)
{
    if (!pZip)
        return MZ_FALSE;

    if (pZip->m_zip_mode == MZ_ZIP_MODE_READING)
        return mz_zip_reader_end(pZip);
#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
    else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))
        return mz_zip_writer_end(pZip);
#endif

    return MZ_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xe41c
movl 0x14(%rdi), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0xe411
popq %rbp
jmp 0xb1a1
cmpl $0x1, %eax
jne 0xe41c
popq %rbp
jmp 0x7abd
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_array_ensure_capacity(mz_zip_archive*, mz_zip_array*, unsigned long, unsigned int)
static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
{
    void *pNew_p;
    size_t new_capacity = min_new_capacity;
    MZ_ASSERT(pArray->m_element_size);
    if (pArray->m_capacity >= min_new_capacity)
        return MZ_TRUE;
    if (growing)
    {
        new_capacity = MZ_MAX(1, pArray->m_capacity);
        while (new_capacity < min_new_capacity)
            new_capacity *= 2;
    }
    if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity)))
        return MZ_FALSE;
    pArray->m_p = pNew_p;
    pArray->m_capacity = new_capacity;
    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r8
movl 0x18(%rsi), %edx
testq %rdx, %rdx
je 0xf602
movq %rsi, %r14
movq 0x10(%rsi), %rsi
pushq $0x1
popq %rbx
cmpq %r8, %rsi
jae 0xf5f5
movq %rdi, %rax
testl %ecx, %ecx
je 0xf5d5
cmpq $0x1, %rsi
adcq $0x0, %rsi
movq %rsi, %r15
addq %rsi, %rsi
cmpq %r8, %r15
jb 0xf5c8
jmp 0xf5d8
movq %r8, %r15
movq 0x40(%rax), %rdi
movq (%r14), %rsi
movq %r15, %rcx
callq *0x38(%rax)
testq %rax, %rax
je 0xf5f3
movq %rax, (%r14)
movq %r15, 0x10(%r14)
jmp 0xf5f5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x74fe(%rip), %rdi      # 0x16b07
leaq 0x6b0e(%rip), %rsi      # 0x1611e
leaq 0x7507(%rip), %rcx      # 0x16b1e
movl $0xc85, %edx            # imm = 0xC85
callq 0x3190
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Property::Property(bool const*, unsigned int)
Property::Property(const bool * array, const uint32_t count) :
        m_type(Type::BooleanArray)
    {
        for (uint32_t i = 0; i < count; ++i)
        {
            Value value;
            value.boolean = array[i];
            m_array.push_back(value);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl $0x6, (%rdi)
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, 0x30(%rdi)
xorl %r14d, %r14d
leaq -0x38(%rbp), %r12
cmpq %r14, %r13
je 0xf735
movb (%r15,%r14), %al
movb %al, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1236c
incq %r14
jmp 0xf719
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1300c
movq %rbx, %rdi
callq 0x12ff8
movq %r15, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Property::Property(int const*, unsigned int)
Property::Property(const int32_t * array, const uint32_t count) :
        m_type(Type::Integer32Array)
    {
        for (uint32_t i = 0; i < count; ++i)
        {
            Value value;
            value.integer32 = array[i];
            m_array.push_back(value);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl $0x7, (%rdi)
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, 0x30(%rdi)
xorl %r14d, %r14d
leaq -0x38(%rbp), %r12
cmpq %r14, %r13
je 0xf7bb
movl (%r15,%r14,4), %eax
movl %eax, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1236c
incq %r14
jmp 0xf79f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1300c
movq %rbx, %rdi
callq 0x12ff8
movq %r15, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Property::Property(long const*, unsigned int)
Property::Property(const int64_t * array, const uint32_t count) :
        m_type(Type::Integer64Array)
    {
        for (uint32_t i = 0; i < count; ++i)
        {
            Value value;
            value.integer64 = array[i];
            m_array.push_back(value);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl $0x8, (%rdi)
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, 0x30(%rdi)
xorl %r14d, %r14d
leaq -0x38(%rbp), %r12
cmpq %r14, %r13
je 0xf842
movq (%r15,%r14,8), %rax
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1236c
incq %r14
jmp 0xf825
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1300c
movq %rbx, %rdi
callq 0x12ff8
movq %r15, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Property::Property(float*, unsigned int)
Property::Property(float * array, const uint32_t count) :
        m_type(Type::Float32Array)
    {
        for (uint32_t i = 0; i < count; ++i)
        {
            Value value;
            value.float32 = array[i];
            m_array.push_back(value);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl $0x9, (%rdi)
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, 0x30(%rdi)
xorl %r14d, %r14d
leaq -0x38(%rbp), %r12
cmpq %r14, %r13
je 0xf8cd
movss (%r15,%r14,4), %xmm0
movss %xmm0, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1236c
incq %r14
jmp 0xf8ad
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1300c
movq %rbx, %rdi
callq 0x12ff8
movq %r15, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Property::Property(double const*, unsigned int)
Property::Property(const double * array, const uint32_t count) :
        m_type(Type::Float64Array)
    {
        for (uint32_t i = 0; i < count; ++i)
        {
            Value value;
            value.float64 = array[i];
            m_array.push_back(value);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl $0xa, (%rdi)
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, 0x30(%rdi)
xorl %r14d, %r14d
leaq -0x38(%rbp), %r12
cmpq %r14, %r13
je 0xf957
movsd (%r15,%r14,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1236c
incq %r14
jmp 0xf937
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1300c
movq %rbx, %rdi
callq 0x12ff8
movq %r15, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Property::size() const
uint32_t Property::size() const
    {
        switch (m_type)
        {
            case Type::Boolean: return 1;
            case Type::Integer16: return 2;
            case Type::Integer32:
            case Type::Float32: return 4;
            case Type::Integer64:
            case Type::Float64: return 8;
            case Type::BooleanArray: return static_cast<uint32_t>(m_array.size());
            case Type::Integer32Array:
            case Type::Float32Array: return static_cast<uint32_t>(m_array.size());
            case Type::Integer64Array:
            case Type::Float64Array: return static_cast<uint32_t>(m_array.size());
            case Type::String:
            case Type::Raw: return static_cast<uint32_t>(m_raw.size());
            default: break;
        }

        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
cmpq $0xc, %rax
ja 0xfafc
leaq 0x70b7(%rip), %rcx      # 0x16b78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
shrq $0x3, %rax
jmp 0xfafe
movl 0x30(%rdi), %eax
subl 0x28(%rdi), %eax
jmp 0xfafe
movl $0x8, %eax
jmp 0xfafe
movl $0x4, %eax
jmp 0xfafe
movl $0x1, %eax
jmp 0xfafe
movl $0x2, %eax
jmp 0xfafe
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Property::string[abi:cxx11]() const
std::string Property::string() const
    {
        switch (m_type)
        {
            case Type::Boolean: return m_primitive.boolean ? "true" : "false";
            case Type::Integer16: return std::to_string(m_primitive.integer16);
            case Type::Integer32: return std::to_string(m_primitive.integer32);
            case Type::Integer64: return std::to_string(m_primitive.integer64);
            case Type::Float32: return std::to_string(m_primitive.float32);
            case Type::Float64: return std::to_string(m_primitive.float64);
            case Type::BooleanArray: return "array(boolean)";
            case Type::Integer32Array: return "array(integer32)";
            case Type::Integer64Array: return "array(integer64)";
            case Type::Float32Array: return "array(float32)";
            case Type::Float64Array: return "array(float64)";
            case Type::String:
            case Type::Raw: return std::string(m_raw.begin(), m_raw.end());
            default: break;
        }

        return "";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0xc, %rax
ja 0xfbfd
leaq 0x7068(%rip), %rcx      # 0x16bac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rdx
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1325a
jmp 0xfc2a
movss 0x8(%rsi), %xmm0
movq %rbx, %rdi
callq 0x124b4
jmp 0xfc2a
leaq 0x71f5(%rip), %rsi      # 0x16d7a
leaq -0xb(%rbp), %rdx
jmp 0xfc22
movl 0x8(%rsi), %esi
jmp 0xfbd7
movq 0x8(%rsi), %rsi
movq %rbx, %rdi
callq 0x12454
jmp 0xfc2a
leaq 0x71ad(%rip), %rsi      # 0x16d58
leaq -0xd(%rbp), %rdx
jmp 0xfc22
leaq 0x7186(%rip), %rcx      # 0x16d3e
leaq 0x7184(%rip), %rax      # 0x16d43
cmpb $0x0, 0x8(%rsi)
cmovneq %rcx, %rax
leaq -0xf(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0xfc25
movswl 0x8(%rsi), %esi
movq %rbx, %rdi
callq 0x123f4
jmp 0xfc2a
movsd 0x8(%rsi), %xmm0
movq %rbx, %rdi
callq 0x124e3
jmp 0xfc2a
leaq 0x7152(%rip), %rsi      # 0x16d49
leaq -0xe(%rbp), %rdx
jmp 0xfc22
leaq 0x657f(%rip), %rsi      # 0x16183
leaq -0x9(%rbp), %rdx
jmp 0xfc22
leaq 0x7178(%rip), %rsi      # 0x16d89
leaq -0xa(%rbp), %rdx
jmp 0xfc22
leaq 0x714b(%rip), %rsi      # 0x16d69
leaq -0xc(%rbp), %rdx
movq %rbx, %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Record::parent(Fbx::Record*)
void Record::parent(Record * parent)
    {
        if (parent == m_pParent)
        {
            return;
        }
        if (parent == this)
        {
            throw std::runtime_error("parent == this.");
        }
        if (parent != nullptr)
        {
            parent->insert(this);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rsi, 0x20(%rdi)
je 0x1214b
movq %rdi, %rax
cmpq %rdi, %rsi
je 0x12150
testq %rsi, %rsi
je 0x1214b
movq %rsi, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xffb4
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3140
movq %rax, %rbx
leaq 0x4d78(%rip), %rsi      # 0x16eda
movq %rax, %rdi
callq 0x30d0
movq 0xae7f(%rip), %rsi      # 0x1cff0
movq 0xae50(%rip), %rdx      # 0x1cfc8
movq %rbx, %rdi
callq 0x3420
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Record::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Record::Iterator Record::find(const std::string & p_name)
    {
        for (auto it = m_nestedList.begin(); it != m_nestedList.end(); it++)
        {
            if ((*it)->name() == p_name)
            {
                return it;
            }
        }
        return m_nestedList.end();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x40, %rbx
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x1224b
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x12792
testb %al, %al
je 0x12231
jmp 0x1224e
movq %rbx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/examples/example1.cpp
// Function: printRecord(Fbx::Record const*, unsigned long)
void printRecord(const Fbx::Record * record, size_t level = 0)
{
    std::cout << std::string(level * 3, ' ') << "Rec: " << record->name() << std::endl;

    for (auto p : record->properties())
    {
        std::cout << std::string((level + 1) * 3, ' ') << "Prop - " << p->code() << ": " << p->string() << std::endl;
    }
    for (auto r : *record)
    {
        printRecord(r, level + 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq (%rsi,%rsi,2), %rsi
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x68(%rbp), %rdi
pushq $0x20
popq %rdx
movq %rsi, -0x30(%rbp)
callq 0x32a0
movq %rbx, -0x40(%rbp)
movq 0x8c3a(%rip), %rdi      # 0x1cfd0
leaq -0x68(%rbp), %rsi
callq 0x3210
leaq 0x2e53(%rip), %rsi      # 0x171f9
movq %rax, %rdi
callq 0x3250
movq %rax, %rbx
movq %r14, %rdi
callq 0x11436
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3210
movq %rax, %rdi
callq 0x3130
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x3120
movq %r14, -0x38(%rbp)
movq %r14, %rdi
callq 0x120e6
movq %rax, %rbx
movq %rax, %rdi
callq 0xfd26
movq %rax, %r13
movq %rbx, %rdi
callq 0xfd3a
movq %rax, -0x48(%rbp)
addq $0x3, -0x30(%rbp)
leaq -0x88(%rbp), %rbx
cmpq -0x48(%rbp), %r13
je 0x144ac
movq 0x10(%r13), %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %r12, %rdi
movq -0x30(%rbp), %rsi
pushq $0x20
popq %rdx
callq 0x32a0
movq 0x8b9a(%rip), %rdi      # 0x1cfd0
movq %r12, %rsi
callq 0x3210
movq %rax, %rdi
leaq 0x2db7(%rip), %rsi      # 0x171ff
callq 0x3250
movq %rax, %r14
movq %r15, %rdi
callq 0xfa9a
movsbl %al, %esi
movq %r14, %rdi
callq 0x32b0
movq %rax, %rdi
leaq 0x2d8f(%rip), %rsi      # 0x171fc
callq 0x3250
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfb28
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3210
movq %rax, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3120
movq %r12, %rdi
callq 0x3120
movq (%r13), %r13
jmp 0x1440a
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x120fa
movq %rax, %rbx
movq %r14, %rdi
callq 0x12104
movq %rax, %r14
movq -0x40(%rbp), %r15
incq %r15
cmpq %r14, %rbx
je 0x144e3
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x14358
movq (%rbx), %rbx
jmp 0x144cd
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x144f8
jmp 0x1450e
jmp 0x1450e
movq %rax, %rbx
jmp 0x1451a
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3120
jmp 0x14511
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/examples/example1.cpp
// Function: main
int main()
{
    Fbx::Record file;
    auto versionCheck = [](std::string magic, uint32_t version)
    {
        if (magic != "Kaydara FBX Binary  ")
        {
            throw std::runtime_error("Invalid magic string.");
        }
        if (version < 7100)
        {
            throw std::runtime_error("I'm not interested in version less than 7100.");
        }
    };

    file.read("../models/blender-default.fbx", versionCheck);
    //printRecord(&file);
    file.write("../bin/out-model.fbx");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
leaq -0xa8(%rbp), %rdi
callq 0xfde8
leaq 0x2cc6(%rip), %rsi      # 0x17207
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30e0
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdx
movaps %xmm0, (%rdx)
leaq 0xab(%rip), %rax        # 0x1460a
movq %rax, 0x18(%rdx)
leaq 0x158(%rip), %rax       # 0x146c2
movq %rax, 0x10(%rdx)
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1002c
leaq -0x50(%rbp), %rdi
callq 0x1258e
leaq -0x30(%rbp), %rdi
callq 0x3120
leaq 0x2c8e(%rip), %rsi      # 0x17225
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30e0
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11440
leaq -0x30(%rbp), %rdi
callq 0x3120
leaq -0xa8(%rbp), %rdi
callq 0xff1e
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x145e8
jmp 0x145f3
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1258e
leaq -0x30(%rbp), %rdi
callq 0x3120
jmp 0x145f6
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0xff1e
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_gnuplot_multi.cpp
// Function: main
int main()
{
   exprtk_gnuplot_fx plotter;

   plotter
   .add_curve(
      exprtk_fx_curve()
         .set_expression("sin(2 * pi * x) + cos(x / 2 * pi)")
         .set_domain(-5,+5)
         .set_title("ExprTk Curve 1"))

   .add_curve(
      exprtk_fx_curve()
         .set_expression("clamp(-1.0,sin(2 * pi * x) + cos(x / 2 * pi),+1.0)")
         .set_domain(-5,+5)
         .set_title("ExprTk Curve 2"));

   plotter.plot();

   return 0;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
leaq 0x150(%rsp), %rdi
callq 0x11062e
leaq 0x100(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, (%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x120(%rsp), %rax
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x12ae31(%rip), %rsi    # 0x23b11f
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11058a
leaq 0x110(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x10e5b0
movaps 0x125cfa(%rip), %xmm0   # 0x236010
movups %xmm0, 0x130(%rsp)
leaq 0x12ae1c(%rip), %rsi    # 0x23b141
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x11058a
leaq 0xf0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x10e5b0
leaq 0x150(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x110850
leaq 0xa0(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, (%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0xc0(%rsp), %rax
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x12adb8(%rip), %rsi    # 0x23b150
leaq 0x30(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x11058a
leaq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10e5b0
movaps 0x125c50(%rip), %xmm0   # 0x236010
movups %xmm0, 0xd0(%rsp)
leaq 0x12adb4(%rip), %rsi    # 0x23b183
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x11058a
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10e5b0
leaq 0x150(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x110850
leaq 0x10(%rsp), %rdi
callq 0x10e628
leaq 0x30(%rsp), %rdi
callq 0x10e628
leaq 0x90(%rsp), %rdi
callq 0x1105c6
leaq 0x50(%rsp), %rdi
callq 0x10e628
leaq 0x70(%rsp), %rdi
callq 0x10e628
leaq 0xf0(%rsp), %rdi
callq 0x1105c6
leaq 0x150(%rsp), %rdi
callq 0x1105dc
leaq 0x150(%rsp), %rdi
callq 0x235af2
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
movq %rax, %rbx
jmp 0x1104d3
jmp 0x110473
movq %rax, %rbx
jmp 0x110496
movq %rax, %rbx
jmp 0x1104a0
jmp 0x11047f
movq %rax, %rbx
jmp 0x1104bc
movq %rax, %rbx
jmp 0x1104c6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x10e628
leaq 0x30(%rsp), %rdi
callq 0x10e628
leaq 0x90(%rsp), %rdi
callq 0x1105c6
jmp 0x1104b2
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x10e628
leaq 0x70(%rsp), %rdi
callq 0x10e628
leaq 0xf0(%rsp), %rdi
callq 0x1105c6
leaq 0x150(%rsp), %rdi
callq 0x235af2
movq %rbx, %rdi
callq 0x10e340
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_gnuplot_multi.cpp
// Function: exprtk_gnuplot_fx::plot()
bool plot()
   {
      for (std::size_t i = 0; i < curve_list_.size(); ++i)
      {
         if (!generate_data(i,curve_list_[i]))
            return false;
      }

      return generate_gp_script();
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x110978
cmpq %rax, %r15
jae 0x110620
movq %r14, %rdi
movq %r15, %rsi
callq 0x235a36
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x110b18
incq %r15
testb %al, %al
jne 0x1105eb
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x110e82
nop
// File: /workspace/github_cpp_makefile_star2_O2/rocket323[P]fishdb/tests/test_main.cpp
// Function: FillPage(std::shared_ptr<fishdb::MemPage>)
void FillPage(std::shared_ptr<MemPage> mp)
{
    for (int i = 0; i < ks; ++i)
        mp->children.push_back(100);
    for (int i = 0; i < ks; ++i)
        mp->kvs.push_back(KV("hello", "world"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq -0xb8(%rbp), %r14
movl 0xac2d(%rip), %eax      # 0xd220
cmpl %eax, %r15d
jge 0x2617
movq (%rbx), %rdi
addq $0x48, %rdi
movq $0x64, -0xb8(%rbp)
movq %r14, %rsi
callq 0x36c4
incl %r15d
jmp 0x25ed
movq %rbx, -0x38(%rbp)
xorl %ecx, %ecx
leaq -0x78(%rbp), %r12
leaq -0xb8(%rbp), %r14
cmpl %eax, %ecx
jge 0x26a8
movl %ecx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %r15
movq %r12, %rdi
leaq 0x59e0(%rip), %rsi      # 0x8020
leaq -0x2a(%rbp), %rdx
callq 0x20c0
leaq -0x58(%rbp), %r13
movq %r13, %rdi
leaq 0x59cf(%rip), %rsi      # 0x8026
leaq -0x29(%rbp), %rdx
callq 0x20c0
movq %r14, %rdi
movq %r12, %rbx
movq %r12, %rsi
movq %r13, %rdx
callq 0x319c
addq $0x60, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x37ae
movq %r14, %rdi
callq 0x31d2
movq %r13, %rdi
callq 0x20f0
movq %rbx, %r12
movq %rbx, %rdi
callq 0x20f0
movl -0x30(%rbp), %ecx
incl %ecx
movl 0xab7a(%rip), %eax      # 0xd220
jmp 0x2628
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x31d2
jmp 0x26ce
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20f0
jmp 0x26dc
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x23f0