LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq -0x18(%rbp), %rax
leaq 0x11e(%rip), %rcx       # 0x12bf0
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movl -0x2c(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x12afe
movq -0x18(%rbp), %rax
leaq -0x58fa(%rip), %rcx     # 0xd200
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x12810
cmpl $0x0, %eax
jne 0x12b2b
movl $0x0, -0x10(%rbp)
jmp 0x12be3
movq -0x18(%rbp), %rax
movl $0x3, 0x18(%rax)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x12b4a
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x12b52
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x12bdc
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq -0x28(%rbp), %rdx
movl $0x1, %esi
callq *%rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x80(%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x12bc9
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x12d90
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x10, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12bc0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x10(%rbp)
jmp 0x12be3
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x90(%rax)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x70(%rax), %rdi
callq 0x3480
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x78(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x13296
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x132c0
movq -0x40(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x70(%rax), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x3510
cmpl $0x0, %eax
je 0x132c0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x16, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x132b6
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq $0x0, -0x18(%rbp)
jmp 0x132e2
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x70(%rax), %rcx
movl $0x1, %esi
callq 0x35c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
leaq -0x10e(%rip), %rcx      # 0x13220
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movl -0x1c(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x1335a
movq -0x10(%rbp), %rax
leaq -0x5e76(%rip), %rcx     # 0xd4e0
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x12810
cmpl $0x0, %eax
jne 0x13384
movl $0x0, -0x4(%rbp)
jmp 0x133c6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x70(%rax), %rdi
callq 0x3480
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_validate_archive_name(char const*)
static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)
{
    /* Basic ZIP archive filename validity checks: Valid filenames cannot start with a forward slash, cannot contain a drive letter, and cannot use DOS-style backward slashes. */
    if (*pArchive_name == '/')
        return MZ_FALSE;

    while (*pArchive_name)
    {
        if ((*pArchive_name == '\\') || (*pArchive_name == ':'))
            return MZ_FALSE;

        pArchive_name++;
    }

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x1523d
movl $0x0, -0x4(%rbp)
jmp 0x1527e
jmp 0x1523f
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x15277
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x15260
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x15269
movl $0x0, -0x4(%rbp)
jmp 0x1527e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1523f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive*)
static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)
{
    mz_uint32 n;
    if (!pZip->m_file_offset_alignment)
        return 0;
    n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1));
    return (mz_uint)((pZip->m_file_offset_alignment - n) & (pZip->m_file_offset_alignment - 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1533c
movl $0x0, -0x4(%rbp)
jmp 0x15375
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
subq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x1050, %rsp           # imm = 0x1050
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
leaq -0x1030(%rbp), %rax
movq %rax, -0x1040(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x1000, %eax           # imm = 0x1000
cmpq %rcx, %rax
jae 0x153c1
movl $0x1000, %eax           # imm = 0x1000
movq %rax, -0x1048(%rbp)
jmp 0x153cb
movl -0x24(%rbp), %eax
movq %rax, -0x1048(%rbp)
movq -0x1040(%rbp), %rdi
movq -0x1048(%rbp), %rdx
xorl %esi, %esi
callq 0x3190
cmpl $0x0, -0x24(%rbp)
je 0x15496
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x1000, %eax           # imm = 0x1000
cmpq %rcx, %rax
jae 0x15407
movl $0x1000, %eax           # imm = 0x1000
movq %rax, -0x1050(%rbp)
jmp 0x15411
movl -0x24(%rbp), %eax
movq %rax, -0x1050(%rbp)
movq -0x1050(%rbp), %rax
movl %eax, -0x1034(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x60(%rcx), %rdi
movq -0x20(%rbp), %rsi
leaq -0x1030(%rbp), %rdx
movl -0x1034(%rbp), %ecx
callq *%rax
movl -0x1034(%rbp), %ecx
cmpq %rcx, %rax
je 0x15475
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x13, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1546c
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x10(%rbp)
jmp 0x1549d
movl -0x1034(%rbp), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x1034(%rbp), %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x153e0
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x1050, %rsp           # imm = 0x1050
popq %rbp
retq
nopl (%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_add_put_buf_callback(void const*, int, void*)
static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser)
{
    mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser;
    if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, pState->m_cur_archive_file_ofs, pBuf, len) != len)
        return MZ_FALSE;

    pState->m_cur_archive_file_ofs += len;
    pState->m_comp_size += len;
    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq 0x60(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rcx
callq *%rax
cmpl -0x14(%rbp), %eax
je 0x15cf1
movl $0x0, -0x4(%rbp)
jmp 0x15d18
movslq -0x14(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movslq -0x14(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movw %r8w, %ax
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movw %ax, -0x42(%rbp)
movl %r9d, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3190
leaq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x18190
cmpl $0x0, %eax
jne 0x18095
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x17, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18089
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x20(%rbp)
jmp 0x18175
movq -0x38(%rbp), %rdi
leaq 0x1e179(%rip), %rsi     # 0x36219
callq 0x3370
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x180dc
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x11, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x180d0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x20(%rbp)
jmp 0x18175
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3510
movq -0x50(%rbp), %rdi
callq 0x3480
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3510
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x68(%rbp), %r8
movq -0x40(%rbp), %r9
movw -0x42(%rbp), %r10w
movl -0x48(%rbp), %eax
xorl %r11d, %r11d
xorl %r11d, %r11d
movzwl %r10w, %r10d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
callq 0x16820
movl %eax, -0x6c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3300
movl -0x6c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_get_file_modified_time(char const*, long*)
static mz_bool mz_zip_get_file_modified_time(const char *pFilename, MZ_TIME_T *pTime)
{
    struct MZ_FILE_STAT_STRUCT file_stat;

    /* On Linux with x86 glibc, this call will fail on large files (I think >= 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh. */
    if (MZ_FILE_STAT(pFilename, &file_stat) != 0)
        return MZ_FALSE;

    *pTime = file_stat.st_mtime;

    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x3530
cmpl $0x0, %eax
je 0x181c1
movl $0x0, -0x4(%rbp)
jmp 0x181d3
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x1c482
cmpq $0x0, -0x48(%rbp)
jne 0x1c4ae
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x18, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c4a2
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x30(%rbp)
jmp 0x1c5c2
movq -0x40(%rbp), %rax
movq $0x0, (%rax)
movq -0x48(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x1c4d6
movq -0x38(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x1c502
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x18, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c4f6
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x30(%rbp)
jmp 0x1c5c2
movq -0x38(%rbp), %rax
leaq -0x991d(%rip), %rcx     # 0x12bf0
cmpq %rcx, 0x50(%rax)
je 0x1c53f
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x18, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1c533
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x30(%rbp)
jmp 0x1c5c2
movq -0x38(%rbp), %rdi
callq 0x1b5d0
cmpl $0x0, %eax
jne 0x1c556
movl $0x0, -0x30(%rbp)
jmp 0x1c5c2
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x80(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x88(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq $0x0, 0x80(%rax)
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq $0x0, 0x90(%rax)
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq $0x0, 0x88(%rax)
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0xb8(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1c930
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x1c93e
cmpq $0x0, -0x18(%rbp)
jne 0x1c95c
cmpq $0x0, -0x38(%rbp)
je 0x1c94f
movq -0x38(%rbp), %rax
movl $0x18, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1ca22
leaq -0xb0(%rbp), %rdi
callq 0xbba0
movq -0x10(%rbp), %rsi
movl -0x2c(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
leaq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0xd2e0
cmpl $0x0, %eax
jne 0x1c9ab
cmpq $0x0, -0x38(%rbp)
je 0x1c9a1
movl -0x94(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1ca22
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
leaq -0xb0(%rbp), %rdi
leaq -0x3c(%rbp), %r8
callq 0xdac0
cmpl $0x0, %eax
je 0x1c9e8
movl -0x3c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
leaq -0xb0(%rbp), %rdi
callq 0xef60
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
leaq -0xb0(%rbp), %rdi
callq 0xbbf0
cmpq $0x0, -0x38(%rbp)
je 0x1ca17
movl -0x94(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_set_last_error
mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)
{
    mz_zip_error prev_err;

    if (!pZip)
        return MZ_ZIP_INVALID_PARAMETER;

    prev_err = pZip->m_last_error;

    pZip->m_last_error = err_num;
    return prev_err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1caeb
movl $0x18, -0x4(%rbp)
jmp 0x1cb05
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_get_last_error
mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip)
{
    mz_zip_error prev_err;

    if (!pZip)
        return MZ_ZIP_INVALID_PARAMETER;

    prev_err = pZip->m_last_error;

    pZip->m_last_error = MZ_ZIP_NO_ERROR;
    return prev_err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1cb78
movl $0x18, -0x4(%rbp)
jmp 0x1cb93
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movq %rdx, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1d012
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1d012
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jb 0x1d01c
movq $0x0, -0x8(%rbp)
jmp 0x1d040
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x68(%rcx), %rcx
movq 0x20(%rcx), %rcx
movl -0x14(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x1d085
cmpl $0x0, -0x44(%rbp)
je 0x1d05c
movq -0x40(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x18, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1d07c
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x28(%rbp)
jmp 0x1d0e4
movq -0x50(%rbp), %rax
movzwl 0x1c(%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x1d0db
movl -0x48(%rbp), %eax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1d0ab
movl -0x48(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x1d0b4
movl -0x44(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x2e, %rsi
movl -0x48(%rbp), %eax
movl %eax, %edx
callq 0x3280
movq -0x40(%rbp), %rax
movl -0x48(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d10c
movl $0x0, -0x4(%rbp)
jmp 0x1d14f
movq -0x10(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jne 0x1d124
movq -0x10(%rbp), %rdi
callq 0xbbd0
movl %eax, -0x4(%rbp)
jmp 0x1d14f
movq -0x10(%rbp), %rax
cmpl $0x2, 0x14(%rax)
je 0x1d138
movq -0x10(%rbp), %rax
cmpl $0x3, 0x14(%rax)
jne 0x1d146
movq -0x10(%rbp), %rdi
callq 0x132f0
movl %eax, -0x4(%rbp)
jmp 0x1d14f
jmp 0x1d148
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_huffman_enforce_max_code_size(int*, int, int)
static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
{
    int i;
    mz_uint32 total = 0;
    if (code_list_len <= 1)
        return;
    for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++)
        pNum_codes[max_code_size] += pNum_codes[i];
    for (i = max_code_size; i > 0; i--)
        total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
    while (total != (1UL << max_code_size))
    {
        pNum_codes[max_code_size]--;
        for (i = max_code_size - 1; i > 0; i--)
            if (pNum_codes[i])
            {
                pNum_codes[i]--;
                pNum_codes[i + 1] += 2;
                break;
            }
        total--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x1f2d0
jmp 0x1f3bd
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jg 0x1f303
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f2d9
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1f333
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x10(%rbp), %ecx
subl -0x14(%rbp), %ecx
shll %cl, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f309
jmp 0x1f335
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
je 0x1f3bd
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1f3af
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1f3a2
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x2, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x1f3af
jmp 0x1f3a4
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f365
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f335
popq %rbp
retq
nop
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_dos_to_time_t(int, int)
static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date)
{
    struct tm tm;
    memset(&tm, 0, sizeof(tm));
    tm.tm_isdst = -1;
    tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;
    tm.tm_mon = ((dos_date >> 5) & 15) - 1;
    tm.tm_mday = dos_date & 31;
    tm.tm_hour = (dos_time >> 11) & 31;
    tm.tm_min = (dos_time >> 5) & 63;
    tm.tm_sec = (dos_time << 1) & 62;
    return mktime(&tm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x3190
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %eax
sarl $0x9, %eax
andl $0x7f, %eax
addl $0x7bc, %eax            # imm = 0x7BC
subl $0x76c, %eax            # imm = 0x76C
movl %eax, -0x2c(%rbp)
movl -0x8(%rbp), %eax
sarl $0x5, %eax
andl $0xf, %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x8(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x34(%rbp)
movl -0x4(%rbp), %eax
sarl $0xb, %eax
andl $0x1f, %eax
movl %eax, -0x38(%rbp)
movl -0x4(%rbp), %eax
sarl $0x5, %eax
andl $0x3f, %eax
movl %eax, -0x3c(%rbp)
movl -0x4(%rbp), %eax
shll %eax
andl $0x3e, %eax
movl %eax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x2024b
jmp 0x2026a
leaq 0x168e7(%rip), %rdi     # 0x36b39
leaq 0x15ec5(%rip), %rsi     # 0x3611e
movl $0xc85, %edx            # imm = 0xC85
leaq 0x168eb(%rip), %rcx     # 0x36b50
callq 0x31d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jb 0x20284
movl $0x1, -0x4(%rbp)
jmp 0x2032c
cmpl $0x0, -0x24(%rbp)
je 0x202d1
movq -0x18(%rbp), %rcx
movl $0x1, %eax
cmpq 0x10(%rcx), %rax
jbe 0x202a4
movl $0x1, %eax
movq %rax, -0x40(%rbp)
jmp 0x202b0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x202cf
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x202b8
jmp 0x202d1
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, %edx
movq -0x38(%rbp), %rcx
callq *%rax
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x2030e
movl $0x0, -0x4(%rbp)
jmp 0x2032c
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x6, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x27d70
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x27d90
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x20b1d
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movb (%rax,%rcx), %al
andb $0x1, %al
movb %al, -0x20(%rbp)
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27db0
jmp 0x20af0
jmp 0x20af2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20ac6
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x27e20
movq -0x48(%rbp), %rdi
callq 0x27e80
jmp 0x20b23
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3560
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x7, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x27d70
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x27d90
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x20bcb
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27db0
jmp 0x20b9e
jmp 0x20ba0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20b76
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x27e20
movq -0x48(%rbp), %rdi
callq 0x27e80
jmp 0x20bd1
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3560
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x8, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x27d70
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x27d90
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x20c7d
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27db0
jmp 0x20c50
jmp 0x20c52
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20c26
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x27e20
movq -0x48(%rbp), %rdi
callq 0x27e80
jmp 0x20c83
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3560
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x9, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x27d70
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x27d90
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x20d2f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x20(%rbp)
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27db0
jmp 0x20d02
jmp 0x20d04
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20cd6
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x27e20
movq -0x48(%rbp), %rdi
callq 0x27e80
jmp 0x20d35
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3560
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0xa, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x27d70
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x27d90
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x20ddf
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27db0
jmp 0x20db2
jmp 0x20db4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20d86
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x27e20
movq -0x48(%rbp), %rdi
callq 0x27e80
jmp 0x20de5
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3560
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0xc, %rax
ja 0x210f4
movq -0x18(%rbp), %rax
leaq 0x15b29(%rip), %rcx     # 0x36ba8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x210fd
movl $0x2, -0x4(%rbp)
jmp 0x210fd
movl $0x4, -0x4(%rbp)
jmp 0x210fd
movl $0x8, -0x4(%rbp)
jmp 0x210fd
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x28020
movl %eax, -0x4(%rbp)
jmp 0x210fd
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x28020
movl %eax, -0x4(%rbp)
jmp 0x210fd
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x28020
movl %eax, -0x4(%rbp)
jmp 0x210fd
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x28040
movl %eax, -0x4(%rbp)
jmp 0x210fd
jmp 0x210f6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25ee0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x21d2d
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25ff0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rdi, 0x20(%rax)
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x48(%rbp)
addq $0x40, %rdi
callq 0x28820
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x29360
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x292f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::(anonymous namespace)::PropertyReader::readPrimitive(unsigned char) const
size_t readPrimitive(uint8_t code) const
            {
                switch (code)
                {
                case 'C': return readPrimitiveValue<bool>();
                case 'Y': return readPrimitiveValue<int16_t>();
                case 'I': return readPrimitiveValue<int32_t>();
                case 'L': return readPrimitiveValue<int64_t>();
                case 'F': return readPrimitiveValue<float>();
                case 'D': return readPrimitiveValue<double>();
                default: throw std::runtime_error("Unkown primitive property type:" + code); break;
                }
                return 0;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movzbl -0x11(%rbp), %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x16, %eax
ja 0x23173
movq -0x30(%rbp), %rax
leaq 0x13b09(%rip), %rcx     # 0x36c10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
callq 0x26440
movq %rax, -0x8(%rbp)
jmp 0x231ca
movq -0x38(%rbp), %rdi
callq 0x264e0
movq %rax, -0x8(%rbp)
jmp 0x231ca
movq -0x38(%rbp), %rdi
callq 0x26570
movq %rax, -0x8(%rbp)
jmp 0x231ca
movq -0x38(%rbp), %rdi
callq 0x26600
movq %rax, -0x8(%rbp)
jmp 0x231ca
movq -0x38(%rbp), %rdi
callq 0x26690
movq %rax, -0x8(%rbp)
jmp 0x231ca
movq -0x38(%rbp), %rdi
callq 0x26720
movq %rax, -0x8(%rbp)
jmp 0x231ca
movl $0x10, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movzbl -0x11(%rbp), %eax
leaq 0x13e3a(%rip), %rsi     # 0x36fcc
addq %rax, %rsi
callq 0x3100
jmp 0x2319c
movq -0x40(%rbp), %rdi
movq 0x21e49(%rip), %rsi     # 0x44ff0
movq 0x21e1a(%rip), %rdx     # 0x44fc8
callq 0x3520
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3230
jmp 0x231d4
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3560
nopl (%rax)
// File: jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::(anonymous namespace)::writeRaw(std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
void writeRaw(std::vector<uint8_t> & data, const std::vector<uint8_t> & raw)
        {
            const uint32_t size = static_cast<uint32_t>(raw.size());
            const uint8_t * pSize = reinterpret_cast<const uint8_t*>(&size);
            data.insert(data.end(), pSize, pSize + 4);
            std::copy(raw.begin(), raw.end(), std::back_inserter(data));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28040
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28cb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x28ce0
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x4, %rcx
movq -0x28(%rbp), %rsi
callq 0x28c10
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28350
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28380
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c8f0
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x2c880
movq %rax, -0x58(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x20(%rcx), %rax
jne 0x25f44
jmp 0x25fb6
movq -0x30(%rbp), %rax
cmpq %rax, -0x10(%rbp)
jne 0x25f9e
movl $0x10, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1100c(%rip), %rsi     # 0x36f75
callq 0x3100
jmp 0x25f70
movq -0x38(%rbp), %rdi
movq 0x1f075(%rip), %rsi     # 0x44ff0
movq 0x1f046(%rip), %rdx     # 0x44fc8
callq 0x3520
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3230
jmp 0x25fbc
cmpq $0x0, -0x10(%rbp)
je 0x25fb6
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x21cf0
movq %rax, -0x28(%rbp)
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25ee0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x26061
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x25ff0
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rax, 0x20(%rcx)
addq $0x40, %rax
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x29360
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x292f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x40, %rdi
callq 0x287c0
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x28820
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x287f0
testb $0x1, %al
jne 0x26219
jmp 0x26251
leaq -0x8(%rbp), %rdi
callq 0x28850
movq (%rax), %rdi
callq 0x23530
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x29460
testb $0x1, %al
jne 0x2623c
jmp 0x2623e
jmp 0x26262
jmp 0x26240
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x294f0
movq %rax, -0x28(%rbp)
jmp 0x261f5
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x28820
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)