LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %r15d
movq %rdi, %rbx
testq %rdi, %rdi
je 0xb227
movq 0x68(%rbx), %r14
testq %r14, %r14
je 0xb227
cmpq $0x0, 0x28(%rbx)
je 0xb227
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0xb227
movl 0x14(%rbx), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0xb227
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, %r12d
testq %rdi, %rdi
je 0xb1e9
cmpl $0x4, 0x18(%rbx)
jne 0xb1e1
callq 0x3250
cmpl $-0x1, %eax
jne 0xb1e1
xorl %r12d, %r12d
testl %r15d, %r15d
je 0xb1e1
movl $0x15, 0x1c(%rbx)
movq $0x0, 0x70(%r14)
leaq -0x1b8(%rip), %rax      # 0xb038
cmpq %rax, 0x50(%rbx)
jne 0xb214
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0xb214
movq 0x40(%rbx), %rdi
callq *0x30(%rbx)
movq $0x0, 0x80(%r14)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq *0x30(%rbx)
movl $0x0, 0x14(%rbx)
jmp 0xb241
testq %rbx, %rbx
sete %al
testl %r15d, %r15d
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0xb241
movl $0x18, 0x1c(%rbx)
movl %r12d, %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_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 0x11f(%rip), %rax       # 0xb3ab
movq %rax, 0x50(%rdi)
movq $0x0, 0x58(%rdi)
testw %r13w, %r13w
jns 0xb2a9
leaq -0x2a80(%rip), %rax     # 0x8825
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0xae58
xorl %r15d, %r15d
testl %eax, %eax
je 0xb396
testw %r13w, %r13w
leaq 0xbf6b(%rip), %rax      # 0x1723c
leaq 0xbf67(%rip), %rsi      # 0x1723f
cmovnsq %rax, %rsi
movq %r12, %rdi
callq 0x3280
testq %rax, %rax
je 0xb378
movq 0x68(%rbx), %rcx
movq %rax, 0x70(%rcx)
movl $0x4, 0x18(%rbx)
testq %r14, %r14
je 0xb370
leaq -0x1030(%rbp), %rdi
xorl %r12d, %r12d
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x3160
movl $0x1000, %eax           # imm = 0x1000
cmpq %rax, %r14
movl $0x1000, %r13d          # imm = 0x1000
cmovbq %r14, %r13
movq 0x60(%rbx), %rdi
movq %r12, %rsi
leaq -0x1030(%rbp), %rdx
movq %r13, %rcx
callq *0x50(%rbx)
movq %rax, %r15
cmpq %r13, %rax
jne 0xb34d
addq %r13, %r12
subq %r13, %r14
jmp 0xb366
movq %rbx, %rdi
movl $0x1, %esi
callq 0xb118
testq %rbx, %rbx
je 0xb366
movl $0x13, 0x1c(%rbx)
cmpq %r13, %r15
jne 0xb393
testq %r14, %r14
jne 0xb317
movl $0x1, %r15d
jmp 0xb396
movq %rbx, %rdi
movl $0x1, %esi
callq 0xb118
testq %rbx, %rbx
je 0xb396
movl $0x11, 0x1c(%rbx)
jmp 0xb396
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_O1/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 0x3370
movq 0x68(%r15), %rcx
addq 0x78(%rcx), %r12
js 0xb3f0
cmpq %r12, %rax
je 0xb408
movq 0x70(%rcx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x33f0
testl %eax, %eax
je 0xb408
testq %r15, %r15
je 0xb3fd
movl $0x16, 0x1c(%r15)
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 0x3470
// File: /workspace/github_cpp_makefile_star2_O1/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 -0xa3(%rip), %rax       # 0xb3ab
movq %rax, 0x50(%rdi)
movq $0x0, 0x58(%rdi)
testw %dx, %dx
jns 0xb46a
leaq -0x2c41(%rip), %rax     # 0x8825
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xae58
testl %eax, %eax
je 0xb4a4
movq 0x68(%rbx), %rax
movq %r14, 0x70(%rax)
movq %r14, %rdi
callq 0x3370
movq 0x68(%rbx), %rcx
movq %rax, 0x78(%rcx)
movl $0x5, 0x18(%rbx)
movl $0x1, %r15d
movl %r15d, %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_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, %r14
movq %rdi, %r15
movl $0x1000, %eax           # imm = 0x1000
cmpl %eax, %edx
movl $0x1000, %edx           # imm = 0x1000
cmovbl %ebx, %edx
leaq -0x1030(%rbp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x3160
testl %ebx, %ebx
je 0xc2ac
movl $0x1000, %eax           # imm = 0x1000
cmpl %eax, %ebx
movl $0x1000, %r13d          # imm = 0x1000
cmovbl %ebx, %r13d
movq 0x60(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq *0x50(%r15)
cmpq %r13, %rax
jne 0xc296
addq %r13, %r14
subl %r13d, %ebx
jmp 0xc2a3
testq %r15, %r15
je 0xc2a3
movl $0x13, 0x1c(%r15)
cmpq %r13, %rax
je 0xc263
xorl %eax, %eax
jmp 0xc2b1
movl $0x1, %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_O1/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, -0x50(%rbp)
movl %r8d, %r15d
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq $0x0, -0x38(%rbp)
leaq -0xe0(%rbp), %rsi
movq %rdx, %rdi
callq 0x3410
testl %eax, %eax
je 0xd1eb
xorl %r15d, %r15d
testq %r14, %r14
je 0xd297
movl $0x17, 0x1c(%r14)
jmp 0xd297
movq %r14, -0x30(%rbp)
movl %r15d, %r14d
movq %r13, -0x40(%rbp)
movq %r12, -0x48(%rbp)
movq -0x50(%rbp), %r15
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xa029(%rip), %rsi      # 0x17239
movq %rbx, %rdi
callq 0x3280
testq %rax, %rax
je 0xd284
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x33f0
movq %rbx, %rdi
callq 0x3370
movq %rax, %r13
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33f0
movzwl %r14w, %eax
leaq -0x38(%rbp), %r8
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq -0x48(%rbp), %r9
pushq %r12
pushq %r12
pushq %r12
pushq %r12
pushq %r15
pushq %rax
callq 0xc734
addq $0x30, %rsp
movl %eax, %r15d
movq %rbx, %rdi
callq 0x3250
jmp 0xd297
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0xd297
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_O1/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 0xe420
movq %rdx, %r15
movq %rsi, %r12
xorl %ebx, %ebx
movq %rbx, (%rsi)
movq %rbx, (%rdx)
testq %r14, %r14
je 0xe42f
cmpq $0x0, 0x68(%r14)
je 0xe422
leaq -0x339d(%rip), %rax     # 0xb038
cmpq %rax, 0x50(%r14)
jne 0xe427
movq %r14, %rdi
callq 0xdfe9
testl %eax, %eax
je 0xe42f
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)
movq $0x0, 0x90(%rax)
movl $0x1, %ebx
jmp 0xe42f
xorl %ebx, %ebx
testq %r14, %r14
je 0xe42f
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_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 0xe6df
movq $0x0, (%r15)
testq %rsi, %rsi
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
je 0xe762
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 0x86eb
testl %eax, %eax
je 0xe771
leaq -0xa0(%rbp), %rdi
leaq -0x2c(%rbp), %r8
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x8ad3
testl %eax, %eax
je 0xe781
movl -0x2c(%rbp), %esi
leaq -0xa0(%rbp), %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x944b
movq %rax, %r14
jmp 0xe784
movl $0x18, %eax
xorl %r14d, %r14d
testq %rbx, %rbx
jne 0xe7a4
jmp 0xe7a6
testq %rbx, %rbx
je 0xe7b8
movl -0x84(%rbp), %eax
xorl %r14d, %r14d
jmp 0xe7a4
xorl %r14d, %r14d
xorl %esi, %esi
testq %r14, %r14
setne %sil
leaq -0xa0(%rbp), %rdi
callq 0x7dc3
testq %rbx, %rbx
je 0xe7a6
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 0xe7a6
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe970
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0xe970
cmpl %esi, 0x10(%rdi)
jbe 0xe970
movq 0x20(%rax), %rcx
movl %esi, %edx
movl (%rcx,%rdx,4), %esi
addq (%rax), %rsi
jmp 0xe972
xorl %esi, %esi
testq %rsi, %rsi
je 0xe9a5
movzwl 0x1c(%rsi), %eax
testl %r14d, %r14d
je 0xe9a1
decl %r14d
cmpl %eax, %r14d
cmovael %eax, %r14d
addq $0x2e, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x31e0
movb $0x0, (%rbx,%r14)
movl %r14d, %eax
incl %eax
jmp 0xe9bb
testl %r14d, %r14d
je 0xe9ad
movb $0x0, (%rbx)
xorl %eax, %eax
testq %rdi, %rdi
je 0xe9bb
movl $0x18, 0x1c(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe9ef
movl 0x14(%rdi), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0xe9df
movl $0x1, %esi
popq %rbp
jmp 0xb118
cmpl $0x1, %eax
jne 0xe9ef
movl $0x1, %esi
popq %rbp
jmp 0x7dc3
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10053
movq %rsi, %r14
movq 0x10(%rsi), %rsi
movl $0x1, %ebx
cmpq %r8, %rsi
jae 0x10046
movq %rdi, %rax
testl %ecx, %ecx
je 0x10026
cmpq $0x1, %rsi
adcq $0x0, %rsi
movq %rsi, %r15
addq %rsi, %rsi
cmpq %r8, %r15
jb 0x10019
jmp 0x10029
movq %r8, %r15
movq 0x40(%rax), %rdi
movq (%r14), %rsi
movq %r15, %rcx
callq *0x38(%rax)
testq %rax, %rax
je 0x10044
movq %rax, (%r14)
movq %r15, 0x10(%r14)
jmp 0x10046
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7acd(%rip), %rdi      # 0x17b27
leaq 0x70dd(%rip), %rsi      # 0x1713e
leaq 0x7ad6(%rip), %rcx      # 0x17b3e
movl $0xc85, %edx            # imm = 0xC85
callq 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movl $0x6, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
testl %edx, %edx
je 0x1019c
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorl %r12d, %r12d
movb (%r15,%r12), %al
movb %al, -0x30(%rbp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x10188
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x10194
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13e8e
incq %r12
cmpq %r12, %r13
jne 0x10169
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x101bc
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x101c9
callq 0x3230
movq %r15, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movl $0x7, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
testl %edx, %edx
je 0x1023c
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorl %r12d, %r12d
movl (%r15,%r12,4), %eax
movl %eax, -0x30(%rbp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x10228
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x10234
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13e8e
incq %r12
cmpq %r12, %r13
jne 0x10209
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x1025c
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10269
callq 0x3230
movq %r15, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movl $0x8, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
testl %edx, %edx
je 0x102d9
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorl %r12d, %r12d
movq (%r15,%r12,8), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x102c5
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x102d1
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13e8e
incq %r12
cmpq %r12, %r13
jne 0x102a9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x102f9
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10306
callq 0x3230
movq %r15, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movl $0x9, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
testl %edx, %edx
je 0x1037c
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorl %r12d, %r12d
movss (%r15,%r12,4), %xmm0
movss %xmm0, -0x30(%rbp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x10368
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x10374
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13e8e
incq %r12
cmpq %r12, %r13
jne 0x10345
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x1039c
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x103a9
callq 0x3230
movq %r15, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movl $0xa, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
testl %edx, %edx
je 0x10420
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movl %edx, %r13d
xorl %r12d, %r12d
movsd (%r15,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x1040c
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x10418
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13e8e
incq %r12
cmpq %r12, %r13
jne 0x103e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x10440
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1044d
callq 0x3230
movq %r15, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x105e4
leaq 0x75ef(%rip), %rcx      # 0x17b98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
shrq $0x3, %rax
jmp 0x105e6
movl 0x30(%rdi), %eax
subl 0x28(%rdi), %eax
jmp 0x105e6
movl $0x8, %eax
jmp 0x105e6
movl $0x4, %eax
jmp 0x105e6
movl $0x1, %eax
jmp 0x105e6
movl $0x2, %eax
jmp 0x105e6
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Record::insert(Fbx::Record*)
Record::Iterator Record::insert(Record * record)
    {
        Record * pParent = record->parent();
        if (pParent)
        {
            pParent->erase(record);
        }

        record->m_pParent = this;
        return m_nestedList.insert(m_nestedList.end(), record);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x20(%rsi)
leaq 0x40(%rdi), %r15
movl $0x18, %edi
callq 0x3260
movq %rax, %r12
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0x50(%r14)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x20(%rdi)
je 0x132d3
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
je 0x132de
testq %rbx, %rbx
je 0x132d3
movq %rbx, 0x20(%r14)
leaq 0x40(%rbx), %r15
movl $0x18, %edi
callq 0x3260
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x4c08(%rip), %rsi      # 0x17efa
movq %rax, %rdi
callq 0x30f0
movq 0x9ce7(%rip), %rsi      # 0x1cfe8
movq 0x9cb8(%rip), %rdx      # 0x1cfc0
movq %rbx, %rdi
callq 0x3400
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Record::insert(std::_List_iterator<Fbx::Record*>, Fbx::Record*)
Record::Iterator Record::insert(Iterator position, Record * record)
    {
        Record * pParent = record->parent();
        if (pParent)
        {
            pParent->erase(record);
        }

        record->m_pParent = this;
        return m_nestedList.insert(position, record);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, 0x20(%rdx)
movl $0x18, %edi
callq 0x3260
movq %rax, %r12
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3050
incq 0x50(%r15)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %r15
addq $0x40, %rbx
cmpq %rbx, %r15
je 0x13418
movq (%rsi), %r14
movq 0x8(%rsi), %r12
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdx
cmpq %r12, %rdx
jne 0x1340b
testq %rdx, %rdx
je 0x13415
movq (%rax), %rdi
movq %r14, %rsi
callq 0x3270
testl %eax, %eax
je 0x13415
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x133ea
jmp 0x13418
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xa0, %rsp
leaq -0xa8(%rbp), %rdi
callq 0x10b90
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x30a6(%rip), %rsi      # 0x18247
leaq 0x30bc(%rip), %rdx      # 0x18264
leaq -0x30(%rbp), %rdi
callq 0x13c08
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdx
movaps %xmm0, (%rdx)
leaq 0xe8(%rip), %rax        # 0x152aa
movq %rax, 0x18(%rdx)
leaq 0x1d9(%rip), %rax       # 0x153a6
movq %rax, 0x10(%rdx)
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10e94
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x151f8
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x15206
callq 0x3230
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x3051(%rip), %rsi      # 0x18265
leaq 0x305e(%rip), %rdx      # 0x18279
callq 0x13c08
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x123d0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1523e
callq 0x3230
leaq -0xa8(%rbp), %rdi
callq 0x10d06
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1528b
movq %rax, %rbx
jmp 0x1527b
jmp 0x15293
movq %rax, %rbx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x1527b
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x15296
callq 0x3230
jmp 0x15296
movq %rax, %rdi
callq 0x139eb
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x10d06
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %ecx, %ecx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %r15
movq 0x48(%rbx), %rax
movq %rax, %rcx
subq 0x28(%rbx), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,4), %rax
movq 0x20(%rbx), %r13
movq 0x30(%rbx), %rcx
subq 0x38(%rbx), %rcx
sarq $0x5, %rcx
imulq %r12, %rcx
addq %rax, %rcx
subq 0x10(%rbx), %r13
sarq $0x5, %r13
imulq %r12, %r13
addq %rcx, %r13
cmpq %r13, %r15
jae 0x119893
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c3f8c
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x119de6
leaq 0x1(%r15), %rcx
testb %al, %al
jne 0x119818
cmpq %r13, %r15
jae 0x119893
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11a2c4
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0xab86(%rip)      # 0xd220
jle 0x26e7
xorl %r15d, %r15d
leaq -0xb8(%rbp), %r14
movq (%rbx), %rdi
movq $0x64, -0xb8(%rbp)
movq 0x50(%rdi), %rsi
cmpq 0x58(%rdi), %rsi
je 0x26cf
movq $0x64, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x50(%rdi)
jmp 0x26db
addq $0x48, %rdi
movq %r14, %rdx
callq 0x3b3a
incl %r15d
cmpl 0xab3b(%rip), %r15d     # 0xd220
jl 0x26a6
movq %rbx, -0x38(%rbp)
cmpl $0x0, 0xab2e(%rip)      # 0xd220
jle 0x27de
xorl %eax, %eax
leaq -0x58(%rbp), %r13
leaq -0x78(%rbp), %rbx
leaq -0xb8(%rbp), %r12
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %r14
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %r13, %r15
movq %r13, %rdi
leaq 0x68f8(%rip), %rsi      # 0x9020
leaq 0x68f6(%rip), %rdx      # 0x9025
callq 0x38b4
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %rbx, %rdi
leaq 0x68e0(%rip), %rsi      # 0x9026
leaq 0x68de(%rip), %rdx      # 0x902b
callq 0x38b4
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3696
addq $0x60, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c10
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x2787
callq 0x2210
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x279f
callq 0x2210
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x27b1
callq 0x2210
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
movl -0x2c(%rbp), %r15d
je 0x27c7
callq 0x2210
incl %r15d
cmpl 0xaa4f(%rip), %r15d     # 0xd220
leaq -0x58(%rbp), %r13
movl %r15d, %eax
jl 0x2709
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x281b
movq %rax, %rbx
jmp 0x2809
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x36fe
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x281b
callq 0x2210
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x282d
callq 0x2210
movq %rbx, %rdi
callq 0x23f0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: dump
void dump (void) {
  Clause * p;
  printf ("p cnf %d %d\n", nvars, nclauses);
  for (p = first_clause; p; p = p->next)
    dump_clause (p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x15966(%rip), %esi     # 0x17130
movl 0x15964(%rip), %edx     # 0x17134
leaq 0xe82d(%rip), %rdi      # 0x10004
xorl %eax, %eax
callq 0x10d0
movq 0x15953(%rip), %r15     # 0x17138
testq %r15, %r15
je 0x182f
leaq 0xfe73(%rip), %rbx      # 0x11664
leaq 0xe8bc(%rip), %r14      # 0x100b4
movq 0x8(%r15), %r12
movl (%r12), %esi
testl %esi, %esi
je 0x181e
addq $0x4, %r12
movq %r14, %rdi
xorl %eax, %eax
callq 0x10d0
movl (%r12), %esi
addq $0x4, %r12
testl %esi, %esi
jne 0x1808
movq %rbx, %rdi
callq 0x1090
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x17f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: msg
static void msg (int level, const char * fmt, ...) {
  va_list ap;
  if (level > verbose) return;
  printf ("c [picomcs] ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2321
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl %edi, 0x14e19(%rip)     # 0x17140
jl 0x2383
movq %rsi, %rbx
leaq 0xdebe(%rip), %rdi      # 0x101f1
xorl %eax, %eax
callq 0x10d0
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1180
movq 0x14c62(%rip), %rbx     # 0x16fd0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1110
movq (%rbx), %rdi
callq 0x1160
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: cumcscb
static void cumcscb (void * state, int nmcs, int nhumus) {
  int * ptr = state;
  *ptr = nmcs;
  ptr[0] = nmcs, ptr[1] = nhumus;
  if (!verbose || (!isatty (1) && verbose == 1)) return;
  if (verbose == 1) fputc ('\r', stdout);
  printf ("c [picomcs] mcs %d humus %d", nmcs, nhumus);
  if (verbose >= 2) fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
cmpl $0x0, 0x14d0a(%rip)     # 0x17140
je 0x2455
movl %edx, %ebx
movl %esi, %ebp
movl $0x1, %edi
callq 0x10a0
movl 0x14cf4(%rip), %ecx     # 0x17140
movl %ecx, %edx
xorl $0x1, %edx
orl %eax, %edx
jne 0x245c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x1, %ecx
jne 0x2475
movq 0x14b68(%rip), %rax     # 0x16fd0
movq (%rax), %rsi
movl $0xd, %edi
callq 0x1110
leaq 0xde7a(%rip), %rdi      # 0x102f6
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10d0
cmpl $0x2, 0x14cb2(%rip)     # 0x17140
jl 0x24a4
movq 0x14b39(%rip), %rax     # 0x16fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1110
movq 0x14b25(%rip), %rax     # 0x16fd0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1160
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: get_line(int, char*, int)
int get_line(int sock, char *buf, int size)
{
	int i = 0;
	char c = '\0';
	int n;

	while ((i < size - 1) && (c != '\n'))
	{
		n = recv(sock, &c, 1, 0);
  /* DEBUG printf("%02X\n", c); */
		if (n > 0)
		{
			if (c == '\r')
			{
				n = recv(sock, &c, 1, MSG_PEEK);
    /* DEBUG printf("%02X\n", c); */
				if ((n > 0) && (c == '\n'))
					recv(sock, &c, 1, 0);
				else
					c = '\n';
			}
			buf[i] = c;
			i++;
		}
		else
			c = '\n';
	}
	buf[i] = '\0';

	return(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x0, -0x29(%rbp)
xorl %r13d, %r13d
cmpl $0x2, %edx
jl 0x3bcd
movl %edx, %r14d
movl %edi, %r15d
decl %r14d
xorl %r13d, %r13d
leaq -0x29(%rbp), %r12
movl $0x1, %edx
movl %r15d, %edi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x30f0
testl %eax, %eax
jle 0x3bab
cmpb $0xd, -0x29(%rbp)
jne 0x3bb5
movl $0x1, %edx
movl %r15d, %edi
movq %r12, %rsi
movl $0x2, %ecx
callq 0x30f0
testl %eax, %eax
jle 0x3bb1
cmpb $0xa, -0x29(%rbp)
jne 0x3bb1
movl $0x1, %edx
movl %r15d, %edi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x30f0
jmp 0x3bb5
movb $0xa, -0x29(%rbp)
jmp 0x3bc2
movb $0xa, -0x29(%rbp)
movb -0x29(%rbp), %al
movslq %r13d, %r13
movb %al, (%rbx,%r13)
incl %r13d
cmpl %r14d, %r13d
jge 0x3bcd
cmpb $0xa, -0x29(%rbp)
jne 0x3b5c
movslq %r13d, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: unimplemented(int)
void unimplemented(int client)
{
	char buf[1024];
//发送501说明相应方法没有实现
	sprintf(buf, "HTTP/1.0 501 Method Not Implemented\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, SERVER_STRING);
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "Content-Type: text/html\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "<HTML><HEAD><TITLE>Method Not Implemented\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "</TITLE></HEAD>\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "<BODY><P>HTTP request method not supported.\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "</BODY></HTML>\r\n");
	send(client, buf, strlen(buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %edi, %ebx
movups 0x3681(%rip), %xmm0     # 0x727d
leaq -0x420(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movups 0x365e(%rip), %xmm0     # 0x726d
movaps %xmm0, (%r14)
movabsq $0xa0d6465746e65, %rax  # imm = 0xA0D6465746E65
movq %rax, 0x1e(%r14)
movq %r14, %rdi
callq 0x3150
xorl %r15d, %r15d
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movups 0x3515(%rip), %xmm0     # 0x7157
movaps %xmm0, (%r14)
movups 0x3513(%rip), %xmm0     # 0x7160
movups %xmm0, 0x9(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movups 0x3500(%rip), %xmm0     # 0x7170
movaps %xmm0, (%r14)
movups 0x34ff(%rip), %xmm0     # 0x717a
movups %xmm0, 0xa(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movb %r15b, 0x2(%r14)
movw $0xa0d, (%r14)          # imm = 0xA0D
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movups 0x35d4(%rip), %xmm0     # 0x7293
movaps %xmm0, (%r14)
movups 0x35d9(%rip), %xmm0     # 0x72a3
movaps %xmm0, 0x10(%r14)
movups 0x35d9(%rip), %xmm0     # 0x72af
movups %xmm0, 0x1c(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movups 0x35c6(%rip), %xmm0     # 0x72bf
movaps %xmm0, (%r14)
movw $0xa, 0x10(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movups 0x35af(%rip), %xmm0     # 0x72d1
movaps %xmm0, (%r14)
movups 0x35b4(%rip), %xmm0     # 0x72e1
movaps %xmm0, 0x10(%r14)
movups 0x35b6(%rip), %xmm0     # 0x72ef
movups %xmm0, 0x1e(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movb %r15b, 0x10(%r14)
movups 0x34db(%rip), %xmm0     # 0x723b
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: serve_file(int, char const*)
void serve_file(int client, const char *filename)
{
	FILE *resource = NULL;
	int numchars = 1;
	char buf[1024];
	buf[0] = 'A'; buf[1] = '\0';//这个赋值不清楚是干什么的
	while ((numchars > 0) && strcmp("\n", buf)) //将HTTP请求头读取并丢弃
		numchars = get_line(client, buf, sizeof(buf));
//打开文件
	resource = fopen(filename, "r");
	if (resource == NULL)
 //如果文件不存在，则返回not_found
		not_found(client);
	else
	{
 //添加HTTP头
		headers(client, filename);
 //并发送文件内容
		cat(client, resource);
	}
	fclose(resource);//关闭文件句柄
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movl %edi, %ebx
movw $0x41, -0x420(%rbp)
xorl %eax, %eax
testb %al, %al
jne 0x3fa6
leaq -0x420(%rbp), %r15
movl %ebx, %edi
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3b2b
testl %eax, %eax
jle 0x3fa6
cmpw $0xa, -0x420(%rbp)
jne 0x3f89
leaq 0x329f(%rip), %rsi      # 0x724c
movq %r14, %rdi
callq 0x33c0
movq %rax, %r14
testq %rax, %rax
je 0x3fd0
movl %ebx, %edi
callq 0x4567
movl %ebx, %edi
movq %r14, %rsi
callq 0x43ea
jmp 0x3fd7
movl %ebx, %edi
callq 0x3d89
movq %r14, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3330