LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb2de
cmpq %r12, %rax
je 0xb2f5
movq 0x70(%rcx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x33f0
testl %eax, %eax
je 0xb2f1
movl $0x16, 0x1c(%r15)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x68(%r15), %rcx
movq 0x70(%rcx), %rcx
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_O3/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 -0x9e(%rip), %rax       # 0xb299
movq %rax, 0x50(%rdi)
movq $0x0, 0x58(%rdi)
testw %dx, %dx
jns 0xb353
leaq -0x2ac2(%rip), %rax     # 0x888d
movq %rax, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xad7a
testl %eax, %eax
je 0xb38d
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_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_zip_writer_write_zeros(mz_zip_archive*, unsigned long, unsigned int)
static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
{
    char buf[4096];
    memset(buf, 0, MZ_MIN(sizeof(buf), n));
    while (n)
    {
        mz_uint32 s = MZ_MIN(sizeof(buf), n);
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);

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

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

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

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

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

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

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

    MZ_FCLOSE(pSrc_file);

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, -0x48(%rbp)
movl %r8d, %r15d
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq -0xe0(%rbp), %rsi
movq %rdx, %rdi
callq 0x3410
testl %eax, %eax
je 0xcff6
xorl %r15d, %r15d
testq %r14, %r14
je 0xd0a2
movl $0x17, 0x1c(%r14)
jmp 0xd0a2
movq %r14, -0x30(%rbp)
movl %r15d, %r14d
movq %r13, -0x38(%rbp)
movq %r12, -0x40(%rbp)
movq -0x48(%rbp), %r15
movq -0x88(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xa21e(%rip), %rsi      # 0x17239
movq %rbx, %rdi
callq 0x3280
testq %rax, %rax
je 0xd08f
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 -0x50(%rbp), %r8
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq -0x40(%rbp), %r9
pushq %r12
pushq %r12
pushq %r12
pushq %r12
pushq %r15
pushq %rax
callq 0xc629
addq $0x30, %rsp
movl %eax, %r15d
movq %rbx, %rdi
callq 0x3250
jmp 0xd0a2
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0xd0a2
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_O3/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 0xe0f4
movq %rdx, %r15
movq %rsi, %r12
xorl %ebx, %ebx
movq %rbx, (%rsi)
movq %rbx, (%rdx)
testq %r14, %r14
je 0xe103
cmpq $0x0, 0x68(%r14)
je 0xe0fb
leaq -0x3158(%rip), %rax     # 0xaf51
cmpq %rax, 0x50(%r14)
jne 0xe0fb
movq %r14, %rdi
callq 0xdc90
testl %eax, %eax
je 0xe103
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 0xe103
xorl %ebx, %ebx
testq %r14, %r14
je 0xe103
movl $0x18, 0x1c(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe3bc
movq $0x0, (%r15)
testq %rsi, %rsi
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
je 0xe43f
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 0x8744
testl %eax, %eax
je 0xe44e
leaq -0xa0(%rbp), %rdi
leaq -0x2c(%rbp), %r8
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x8b1a
testl %eax, %eax
je 0xe45e
movl -0x2c(%rbp), %esi
leaq -0xa0(%rbp), %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x942a
movq %rax, %r14
jmp 0xe461
movl $0x18, %eax
xorl %r14d, %r14d
testq %rbx, %rbx
jne 0xe481
jmp 0xe483
testq %rbx, %rbx
je 0xe495
movl -0x84(%rbp), %eax
xorl %r14d, %r14d
jmp 0xe481
xorl %r14d, %r14d
xorl %esi, %esi
testq %r14, %r14
setne %sil
leaq -0xa0(%rbp), %rdi
callq 0x7dd1
testq %rbx, %rbx
je 0xe483
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 0xe483
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe67e
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xe67e
movl %esi, %eax
cmpl %esi, 0x10(%rdi)
jbe 0xe67e
movq (%rcx), %rsi
testq %rsi, %rsi
je 0xe67e
movq 0x20(%rcx), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
addq %rax, %rsi
movzwl 0x1c(%rsi), %eax
testl %r14d, %r14d
je 0xe67a
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 0xe694
testl %r14d, %r14d
je 0xe686
movb $0x0, (%rbx)
xorl %eax, %eax
testq %rdi, %rdi
je 0xe694
movl $0x18, 0x1c(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe6c8
movl 0x14(%rdi), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0xe6b8
movl $0x1, %esi
popq %rbp
jmp 0xb027
cmpl $0x1, %eax
jne 0xe6c8
movl $0x1, %esi
popq %rbp
jmp 0x7dd1
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfdd2
movq %rsi, %r14
movq 0x10(%rsi), %rsi
movl $0x1, %ebx
cmpq %r8, %rsi
jae 0xfdc5
movq %rdi, %rax
testl %ecx, %ecx
je 0xfda5
cmpq $0x1, %rsi
adcq $0x0, %rsi
movq %rsi, %r15
addq %rsi, %rsi
cmpq %r8, %r15
jb 0xfd98
jmp 0xfda8
movq %r8, %r15
movq 0x40(%rax), %rdi
movq (%r14), %rsi
movq %r15, %rcx
callq *0x38(%rax)
testq %rax, %rax
je 0xfdc3
movq %rax, (%r14)
movq %r15, 0x10(%r14)
jmp 0xfdc5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7d4e(%rip), %rdi      # 0x17b27
leaq 0x735e(%rip), %rsi      # 0x1713e
leaq 0x7d57(%rip), %rcx      # 0x17b3e
movl $0xc85, %edx            # imm = 0xC85
callq 0x3170
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0xff1c
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 0xff08
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0xff14
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13c42
incq %r12
cmpq %r12, %r13
jne 0xfee9
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 0xff3c
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xff49
callq 0x3230
movq %r15, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xffbc
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 0xffa8
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0xffb4
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13c42
incq %r12
cmpq %r12, %r13
jne 0xff89
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 0xffdc
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xffe9
callq 0x3230
movq %r15, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10059
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 0x10045
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x10051
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13c42
incq %r12
cmpq %r12, %r13
jne 0x10029
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 0x10079
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10086
callq 0x3230
movq %r15, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x100fc
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 0x100e8
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x100f4
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13c42
incq %r12
cmpq %r12, %r13
jne 0x100c5
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 0x1011c
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10129
callq 0x3230
movq %r15, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1019d
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 0x10189
movsd %xmm0, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x10195
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x13c42
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 0x101bd
callq 0x3230
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x101ca
callq 0x3230
movq %r15, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10360
leaq 0x7873(%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 0x10362
movl 0x30(%rdi), %eax
subl 0x28(%rdi), %eax
jmp 0x10362
movl $0x8, %eax
jmp 0x10362
movl $0x4, %eax
jmp 0x10362
movl $0x1, %eax
jmp 0x10362
movl $0x2, %eax
jmp 0x10362
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13075
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
je 0x13080
testq %rbx, %rbx
je 0x13075
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 0x4e66(%rip), %rsi      # 0x17efa
movq %rax, %rdi
callq 0x30f0
movq 0x9f45(%rip), %rsi      # 0x1cfe8
movq 0x9f16(%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_O3/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), %r12
addq $0x40, %rbx
cmpq %rbx, %r12
je 0x131bc
movq (%rsi), %r14
movq 0x8(%rsi), %r15
movq 0x10(%r12), %rax
cmpq %r15, 0x8(%rax)
jne 0x131ae
testq %r15, %r15
je 0x131b9
movq (%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3270
testl %eax, %eax
je 0x131b9
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x1318c
jmp 0x131bc
movq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10912
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x32b2(%rip), %rsi      # 0x18227
leaq 0x32c8(%rip), %rdx      # 0x18244
leaq -0x30(%rbp), %rdi
callq 0x139ac
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdx
movaps %xmm0, (%rdx)
leaq 0xe8(%rip), %rax        # 0x1507e
movq %rax, 0x18(%rdx)
leaq 0x1d9(%rip), %rax       # 0x1517a
movq %rax, 0x10(%rdx)
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10c28
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x14fcc
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x14fda
callq 0x3230
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x325d(%rip), %rsi      # 0x18245
leaq 0x326a(%rip), %rdx      # 0x18259
callq 0x139ac
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12110
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x15012
callq 0x3230
leaq -0xa8(%rbp), %rdi
callq 0x10a94
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1505f
movq %rax, %rbx
jmp 0x1504f
jmp 0x15067
movq %rax, %rbx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x1504f
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1506a
callq 0x3230
jmp 0x1506a
movq %rax, %rdi
callq 0x13776
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x10a94
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
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), %rcx
movq 0x30(%rbx), %rdx
subq 0x38(%rbx), %rdx
sarq $0x5, %rdx
imulq %r12, %rdx
addq %rax, %rdx
subq 0x10(%rbx), %rcx
sarq $0x5, %rcx
imulq %r12, %rcx
addq %rdx, %rcx
cmpq %rcx, %r15
jae 0x117816
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a0cf2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x117d72
incq %r15
testb %al, %al
jne 0x1177a2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11823a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x38(%rbp)
movl 0xab86(%rip), %eax      # 0xd220
testl %eax, %eax
jle 0x27e1
xorl %r15d, %r15d
leaq -0xb8(%rbp), %r14
movq -0x38(%rbp), %rbx
movq (%rbx), %rdi
movq $0x64, -0xb8(%rbp)
movq 0x50(%rdi), %rsi
cmpq 0x58(%rdi), %rsi
je 0x26d9
movq $0x64, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x50(%rdi)
jmp 0x26eb
addq $0x48, %rdi
movq %r14, %rdx
callq 0x3b04
movl 0xab35(%rip), %eax      # 0xd220
incl %r15d
cmpl %eax, %r15d
jl 0x26b0
testl %eax, %eax
jle 0x27e1
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 0x68f5(%rip), %rsi      # 0x9020
leaq 0x68f3(%rip), %rdx      # 0x9025
callq 0x3870
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %rbx, %rdi
leaq 0x68dd(%rip), %rsi      # 0x9026
leaq 0x68db(%rip), %rdx      # 0x902b
callq 0x3870
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x364e
addq $0x60, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x3bda
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x278a
callq 0x2210
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x27a2
callq 0x2210
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x27b4
callq 0x2210
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
movl -0x2c(%rbp), %r15d
je 0x27ca
callq 0x2210
incl %r15d
cmpl 0xaa4c(%rip), %r15d     # 0xd220
leaq -0x58(%rbp), %r13
movl %r15d, %eax
jl 0x270c
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x281e
movq %rax, %rbx
jmp 0x280c
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x36b6
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x281e
callq 0x2210
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2830
callq 0x2210
movq %rbx, %rdi
callq 0x23f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfe65(%rip), %rbx      # 0x11656
leaq 0xe8b0(%rip), %r14      # 0x100a8
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_O3/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 0x22e2
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, 0x14e58(%rip)     # 0x17140
jl 0x2344
movq %rsi, %rbx
leaq 0xdef1(%rip), %rdi      # 0x101e5
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 0x14ca1(%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_O3/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, 0x14d4d(%rip)     # 0x17140
je 0x2412
movl %edx, %ebx
movl %esi, %ebp
movl $0x1, %edi
callq 0x10a0
movl 0x14d37(%rip), %ecx     # 0x17140
movl %ecx, %edx
xorl $0x1, %edx
orl %eax, %edx
jne 0x2419
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x1, %ecx
jne 0x2432
movq 0x14bab(%rip), %rax     # 0x16fd0
movq (%rax), %rsi
movl $0xd, %edi
callq 0x1110
leaq 0xdeb1(%rip), %rdi      # 0x102ea
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10d0
cmpl $0x2, 0x14cf5(%rip)     # 0x17140
jl 0x2461
movq 0x14b7c(%rip), %rax     # 0x16fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1110
movq 0x14b68(%rip), %rax     # 0x16fd0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3bbd
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 0x3bbd
movb -0x29(%rbp), %al
cmpb $0xd, %al
jne 0x3ba3
movl $0x1, %edx
movl %r15d, %edi
movq %r12, %rsi
movl $0x2, %ecx
callq 0x30f0
testl %eax, %eax
jle 0x3bb5
cmpb $0xa, -0x29(%rbp)
jne 0x3bb5
movl $0x1, %edx
movl %r15d, %edi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x30f0
movb -0x29(%rbp), %al
movb %al, (%rbx,%r13)
incq %r13
cmpl %r14d, %r13d
jge 0x3bbd
cmpb $0xa, %al
jne 0x3b52
jmp 0x3bbd
movb $0xa, (%rbx,%r13)
incl %r13d
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_O3/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 0x3691(%rip), %xmm0     # 0x727d
leaq -0x420(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movups 0x366e(%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 0x3525(%rip), %xmm0     # 0x7157
movaps %xmm0, (%r14)
movups 0x3523(%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 0x3510(%rip), %xmm0     # 0x7170
movaps %xmm0, (%r14)
movups 0x350f(%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 0x35e4(%rip), %xmm0     # 0x7293
movaps %xmm0, (%r14)
movups 0x35e9(%rip), %xmm0     # 0x72a3
movaps %xmm0, 0x10(%r14)
movups 0x35e9(%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 0x35d6(%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 0x35bf(%rip), %xmm0     # 0x72d1
movaps %xmm0, (%r14)
movups 0x35c4(%rip), %xmm0     # 0x72e1
movaps %xmm0, 0x10(%r14)
movups 0x35c6(%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 0x34eb(%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_O3/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 0x3f96
leaq -0x420(%rbp), %r15
movl %ebx, %edi
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3b25
testl %eax, %eax
jle 0x3f96
cmpw $0xa, -0x420(%rbp)
jne 0x3f79
leaq 0x32af(%rip), %rsi      # 0x724c
movq %r14, %rdi
callq 0x33c0
movq %rax, %r14
testq %rax, %rax
je 0x3fc0
movl %ebx, %edi
callq 0x4563
movl %ebx, %edi
movq %r14, %rsi
callq 0x43e6
jmp 0x3fc7
movl %ebx, %edi
callq 0x3d79
movq %r14, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: bad_request(int)
void bad_request(int client)
{
	char buf[1024];
//发送400
	sprintf(buf, "HTTP/1.0 400 BAD REQUEST\r\n");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "Content-type: text/html\r\n");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "\r\n");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "<P>Your browser sent a bad request, ");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "such as a POST without a Content-Length.\r\n");
	send(client, buf, sizeof(buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edi, %ebx
movups 0x2d37(%rip), %xmm0     # 0x703d
leaq -0x410(%rbp), %r14
movups %xmm0, 0xb(%r14)
movups 0x2d19(%rip), %xmm0     # 0x7032
movaps %xmm0, (%r14)
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x31b0
movups 0x2d1a(%rip), %xmm0     # 0x704d
movaps %xmm0, (%r14)
movups 0x2d19(%rip), %xmm0     # 0x7057
movups %xmm0, 0xa(%r14)
movl $0x400, %edx            # imm = 0x400
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x31b0
movw $0xa0d, (%r14)          # imm = 0xA0D
movb $0x0, 0x2(%r14)
movl $0x400, %edx            # imm = 0x400
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x31b0
movabsq $0x202c7473657571, %rax # imm = 0x202C7473657571
movq %rax, 0x1d(%r14)
movups 0x2ce2(%rip), %xmm0     # 0x7067
movaps %xmm0, (%r14)
movups 0x2ce7(%rip), %xmm0     # 0x7077
movaps %xmm0, 0x10(%r14)
movl $0x400, %edx            # imm = 0x400
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x31b0
movups 0x2cdf(%rip), %xmm0     # 0x708c
movaps %xmm0, (%r14)
movups 0x2ce4(%rip), %xmm0     # 0x709c
movaps %xmm0, 0x10(%r14)
movups 0x2ce3(%rip), %xmm0     # 0x70a7
movups %xmm0, 0x1b(%r14)
movl $0x400, %edx            # imm = 0x400
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x31b0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: cannot_execute(int)
void cannot_execute(int client)
{
	char buf[1024];
//发送500
	sprintf(buf, "HTTP/1.0 500 Internal Server Error\r\n");
	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, "<P>Error prohibited CGI execution.\r\n");
	send(client, buf, strlen(buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edi, %ebx
movups 0x2c4b(%rip), %xmm0     # 0x70c7
leaq -0x410(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movups 0x2c28(%rip), %xmm0     # 0x70b7
movaps %xmm0, (%r14)
movabsq $0xa0d726f727245, %rax  # imm = 0xA0D726F727245
movq %rax, 0x1d(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movups 0x2b8e(%rip), %xmm0     # 0x704d
movaps %xmm0, (%r14)
movups 0x2b8d(%rip), %xmm0     # 0x7057
movups %xmm0, 0xa(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movw $0xa0d, (%r14)          # imm = 0xA0D
movb $0x0, 0x2(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
movabsq $0xa0d2e6e6f6974, %rax  # imm = 0xA0D2E6E6F6974
movq %rax, 0x1d(%r14)
movups 0x2bbf(%rip), %xmm0     # 0x70dc
movaps %xmm0, (%r14)
movups 0x2bc4(%rip), %xmm0     # 0x70ec
movaps %xmm0, 0x10(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: headers(int, char const*)
void headers(int client, const char *filename)
{
	char buf[1024];
	(void)filename;  /* could use filename to determine file type */
//发送HTTP头
	strcpy(buf, "HTTP/1.0 200 OK\r\n");
	send(client, buf, strlen(buf), 0);
	strcpy(buf, SERVER_STRING);
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "Content-Type: text/html\r\n");
	send(client, buf, strlen(buf), 0);
	strcpy(buf, "\r\n");
	send(client, buf, strlen(buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edi, %ebx
movups 0x2b97(%rip), %xmm0     # 0x7111
leaq -0x410(%rbp), %r14
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 0x2bad(%rip), %xmm0     # 0x7157
movaps %xmm0, (%r14)
movups 0x2bab(%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 0x2b98(%rip), %xmm0     # 0x7170
movaps %xmm0, (%r14)
movups 0x2b97(%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
movw $0xa0d, (%r14)          # imm = 0xA0D
movb $0x0, 0x2(%r14)
movq %r14, %rdi
callq 0x3150
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: startup(unsigned short*)
int startup(u_short *port)
{

//服务器处理步骤
/*
第一步：创建端口号，使用函数int socketid = socket(family, type, protocol);;
第二步：将地址结构体绑定在端口号上，使用函数int bind(int fd, const struct sockaddr *, socklen_t);
第三步：循环监听客户端请求，使用函数listen(sockfd, 5);（第一个参数是 socket 描述符，第二个参数是最大连接数）

第四步：接受客户端的请求，new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c);
第五步：使用read()/write()进行数据交换
第六步：关闭连接，使用close(socketid);
*/


//客户端处理步骤
/*
第一步：创建端口号，使用函数int socketid = socket(family, type, protocol);
第二步：将地址结构体绑定在端口号上，使用函数int bind(int fd, const struct sockaddr *, socklen_t);
第三步：请求连接，使用函数int connect(int socket, const struct sockaddr* address, size_t address_len)；

第四步：使用read()/write()进行数据交换；
第五步：关闭连接，使用close(socketid);
*/
	int httpd = 0;
	struct sockaddr_in name;
//设置http socket
	httpd = socket(PF_INET, SOCK_STREAM, 0);
	if (httpd == -1)
		error_die("socket");
	memset(&name, 0, sizeof(name));

 //创建地址结构体struct sockaddr_in，主要包含地址和端口号
	name.sin_family = AF_INET;
	name.sin_port = htons(*port);
	name.sin_addr.s_addr = htonl(INADDR_ANY);


 //绑定端口
	if (bind(httpd, (struct sockaddr *)&name, sizeof(name)) < 0)
		error_die("bind");
	if (*port == 0)  /*动态分配一个端口 */
	{
		socklen_t  namelen = sizeof(name);
		if (getsockname(httpd, (struct sockaddr *)&name, &namelen) == -1)
			error_die("getsockname");
		*port = ntohs(name.sin_port);
	}
 //监听连接
	if (listen(httpd, 5) < 0)
		error_die("listen");
	return(httpd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
cmpl $-0x1, %eax
je 0x46cf
movl %eax, %ebx
leaq -0x24(%rbp), %rsi
movq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rsi)
movl $0x0, 0x4(%rsi)
movl %ebx, %edi
movl $0x10, %edx
callq 0x3060
testl %eax, %eax
js 0x46d4
cmpw $0x0, (%r14)
jne 0x46b4
leaq -0x14(%rbp), %rdx
movl $0x10, (%rdx)
leaq -0x24(%rbp), %rsi
movl %ebx, %edi
callq 0x32f0
cmpl $-0x1, %eax
je 0x46de
movzwl -0x22(%rbp), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movl %ebx, %edi
movl $0x5, %esi
callq 0x3390
testl %eax, %eax
js 0x46d9
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x35ee
callq 0x35d6
callq 0x35a6
callq 0x35be