LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-unix.c
// Function: de_current_time_to_timestamp
void de_current_time_to_timestamp(struct de_timestamp *ts)
{
	struct timeval tv;
	int ret;

	de_zeromem(&tv, sizeof(struct timeval));
	ret = gettimeofday(&tv, NULL);
	if(ret!=0) {
		de_zeromem(ts, sizeof(struct de_timestamp));
		return;
	}

	de_unix_time_to_timestamp((i64)tv.tv_sec, ts, 0x1);
	de_timestamp_set_subsec(ts, ((double)tv.tv_usec)/1000000.0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x18110
testl %eax, %eax
je 0xfccda
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq (%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xe002e
cvtsi2sdq 0x8(%rsp), %xmm0
divsd 0x42708(%rip), %xmm0    # 0x13f400
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xe0071
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: mz_adler32
mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
{
    mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16);
    size_t block_len = buf_len % 5552;
    if (!ptr)
        return MZ_ADLER32_INIT;
    while (buf_len)
    {
        for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
        {
            s1 += ptr[0], s2 += s1;
            s1 += ptr[1], s2 += s1;
            s1 += ptr[2], s2 += s1;
            s1 += ptr[3], s2 += s1;
            s1 += ptr[4], s2 += s1;
            s1 += ptr[5], s2 += s1;
            s1 += ptr[6], s2 += s1;
            s1 += ptr[7], s2 += s1;
        }
        for (; i < block_len; ++i)
            s1 += *ptr++, s2 += s1;
        s1 %= 65521U, s2 %= 65521U;
        buf_len -= block_len;
        block_len = 5552;
    }
    return (s2 << 16) + s1;
}

// Assembly:
testq %rsi, %rsi
je 0xfce0b
movq %rdx, %rcx
movl $0x15b0, %r8d           # imm = 0x15B0
movq %rdx, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %r8
movq %rdi, %r10
shrq $0x10, %r10
movzwl %di, %r9d
movl $0xfff1, %edi           # imm = 0xFFF1
testq %rcx, %rcx
je 0xfce02
xorl %r11d, %r11d
leal 0x7(%r11), %eax
cmpl %r8d, %eax
jae 0xfcdd8
movzbl (%rsi,%r11), %eax
addl %eax, %r9d
addl %r9d, %r10d
movzbl 0x1(%rsi,%r11), %eax
addl %r9d, %eax
addl %eax, %r10d
movzbl 0x2(%rsi,%r11), %edx
addl %eax, %edx
addl %edx, %r10d
movzbl 0x3(%rsi,%r11), %eax
addl %edx, %eax
addl %eax, %r10d
movzbl 0x4(%rsi,%r11), %edx
addl %eax, %edx
addl %edx, %r10d
movzbl 0x5(%rsi,%r11), %eax
addl %edx, %eax
addl %eax, %r10d
movzbl 0x6(%rsi,%r11), %edx
addl %eax, %edx
addl %edx, %r10d
movzbl 0x7(%rsi,%r11), %r9d
addl %edx, %r9d
addl %r9d, %r10d
addq $0x8, %r11
jmp 0xfcd61
movzbl (%rsi,%r11), %eax
addl %eax, %r9d
addl %r9d, %r10d
incq %r11
cmpl %r8d, %r11d
jb 0xfcdca
movl %r9d, %eax
xorl %edx, %edx
divl %edi
movl %edx, %r9d
movl %r10d, %eax
xorl %edx, %edx
divl %edi
subq %r8, %rcx
addq %r11, %rsi
movl $0x15b0, %r8d           # imm = 0x15B0
movl %edx, %r10d
jmp 0xfcd55
shll $0x10, %r10d
orl %r9d, %r10d
jmp 0xfce0f
pushq $0x1
popq %r10
movq %r10, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: mz_deflateInit2
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
{
    tdefl_compressor *pComp;
    mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);

    if (!pStream)
        return MZ_STREAM_ERROR;
    if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)))
        return MZ_PARAM_ERROR;

    pStream->data_type = 0;
    pStream->adler = MZ_ADLER32_INIT;
    pStream->msg = NULL;
    pStream->reserved = 0;
    pStream->total_in = 0;
    pStream->total_out = 0;
    if (!pStream->zalloc)
        pStream->zalloc = miniz_def_alloc_func;
    if (!pStream->zfree)
        pStream->zfree = miniz_def_free_func;

    pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
    if (!pComp)
        return MZ_MEM_ERROR;

    pStream->state = (struct mz_internal_state *)pComp;

    if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
    {
        mz_deflateEnd(pStream);
        return MZ_PARAM_ERROR;
    }

    return MZ_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
movl %esi, %edi
movl %ecx, %esi
movl %r9d, %edx
callq 0xfcf33
testq %rbx, %rbx
je 0xfcf1f
movl %eax, %ebp
cmpl $0x8, %r12d
setne %al
addl $-0xa, %r14d
cmpl $-0x9, %r14d
setb %cl
orb %al, %cl
movl $0xffffd8f0, %r14d      # imm = 0xFFFFD8F0
jne 0xfcf23
cmpl $0xf, %r15d
je 0xfceac
cmpl $-0xf, %r15d
jne 0xfcf23
andl $0x0, 0x58(%rbx)
movq $0x1, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0xfcedd
leaq -0xc1(%rip), %rax       # 0xfce18
movq %rax, 0x40(%rbx)
cmpq $0x0, 0x48(%rbx)
jne 0xfceef
leaq -0xc7(%rip), %rcx       # 0xfce24
movq %rcx, 0x48(%rbx)
movq 0x50(%rbx), %rdi
pushq $0x1
popq %rsi
movl $0x4df78, %edx          # imm = 0x4DF78
callq *%rax
testq %rax, %rax
je 0xfcf2f
orl $0x2000, %ebp           # imm = 0x2000
movq %rax, 0x38(%rbx)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
callq 0xfcfa4
jmp 0xfcf23
pushq $-0x2
popq %r14
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x4
jmp 0xfcf21
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tdefl_create_comp_flags_from_zip_params
mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
{
    mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
    if (window_bits > 0)
        comp_flags |= TDEFL_WRITE_ZLIB_HEADER;

    if (!level)
        comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
    else if (strategy == MZ_FILTERED)
        comp_flags |= TDEFL_FILTER_MATCHES;
    else if (strategy == MZ_HUFFMAN_ONLY)
        comp_flags &= ~TDEFL_MAX_PROBES_MASK;
    else if (strategy == MZ_FIXED)
        comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
    else if (strategy == MZ_RLE)
        comp_flags |= TDEFL_RLE_MATCHES;

    return comp_flags;
}

// Assembly:
cmpl $0xa, %edi
pushq $0xa
popq %rax
cmovbl %edi, %eax
testl %edi, %edi
pushq $0x6
popq %rcx
cmovnsl %eax, %ecx
leaq 0x42645(%rip), %rax     # 0x13f590
xorl %r8d, %r8d
cmpl $0x4, %edi
setl %r8b
shll $0xe, %r8d
orl (%rax,%rcx,4), %r8d
movl %r8d, %eax
orl $0x1000, %eax           # imm = 0x1000
testl %esi, %esi
cmovlel %r8d, %eax
testl %edi, %edi
je 0xfcf8c
decl %edx
cmpl $0x3, %edx
ja 0xfcf97
leaq 0x42523(%rip), %rcx     # 0x13f4a0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
orl $0x20000, %eax          # imm = 0x20000
retq
orl $0x80000, %eax          # imm = 0x80000
retq
orl $0x10000, %eax          # imm = 0x10000
retq
orl $0x40000, %eax          # imm = 0x40000
retq
andl $0xfffff000, %eax       # imm = 0xFFFFF000
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: mz_deflateEnd
int mz_deflateEnd(mz_streamp pStream)
{
    if (!pStream)
        return MZ_STREAM_ERROR;
    if (pStream->state)
    {
        pStream->zfree(pStream->opaque, pStream->state);
        pStream->state = NULL;
    }
    return MZ_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xfd0e8
movq %rdi, %r14
movq 0x38(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0xfd0eb
movq 0x50(%r14), %rdi
callq *0x48(%r14)
andq $0x0, 0x38(%r14)
jmp 0xfd0eb
pushq $-0x2
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: mz_deflateReset
int mz_deflateReset(mz_streamp pStream)
{
    if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
        return MZ_STREAM_ERROR;
    pStream->total_in = pStream->total_out = 0;
    tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
    return MZ_OK;
}

// Assembly:
pushq %rbx
pushq $-0x2
popq %rbx
testq %rdi, %rdi
je 0xfd130
movq %rdi, %rax
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xfd130
cmpq $0x0, 0x40(%rax)
je 0xfd130
cmpq $0x0, 0x48(%rax)
je 0xfd130
andq $0x0, 0x28(%rax)
andq $0x0, 0x10(%rax)
movl 0x10(%rdi), %ecx
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0xfcfa4
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: mz_compress2
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
{
    int status;
    mz_stream stream;
    memset(&stream, 0, sizeof(stream));

    /* In case mz_ulong is 64-bits (argh I hate longs). */
    if ((mz_uint64)(source_len | *pDest_len) > 0xFFFFFFFFU)
        return MZ_PARAM_ERROR;

    stream.next_in = pSource;
    stream.avail_in = (mz_uint32)source_len;
    stream.next_out = pDest;
    stream.avail_out = (mz_uint32)*pDest_len;

    status = mz_deflateInit(&stream, level);
    if (status != MZ_OK)
        return status;

    status = mz_deflate(&stream, MZ_FINISH);
    if (status != MZ_STREAM_END)
    {
        mz_deflateEnd(&stream);
        return (status == MZ_OK) ? MZ_BUF_ERROR : status;
    }

    *pDest_len = stream.total_out;
    return mz_deflateEnd(&stream);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
andq $0x0, 0x68(%rsp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %ebp       # imm = 0xFFFFD8F0
jne 0xfde1e
movq %rsp, %rax
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movq %rdi, 0x18(%rax)
movl %esi, 0x20(%rax)
movq %rax, %rdi
movl %r8d, %esi
callq 0xfce43
movl %eax, %ebp
testl %eax, %eax
jne 0xfde1e
movq %rsp, %rdi
pushq $0x4
popq %rsi
callq 0xfd134
cmpl $0x1, %eax
jne 0xfddfe
movq 0x28(%rsp), %rax
movq %rax, (%rbx)
movq 0x38(%rsp), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
je 0xfde1e
movq 0x50(%rsp), %rdi
callq *0x48(%rsp)
jmp 0xfde1e
movl %eax, %r14d
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0xfde14
movq 0x50(%rsp), %rdi
callq *0x48(%rsp)
testl %r14d, %r14d
pushq $-0x5
popq %rbp
cmovnel %r14d, %ebp
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: mz_inflateInit2
int mz_inflateInit2(mz_streamp pStream, int window_bits)
{
    inflate_state *pDecomp;
    if (!pStream)
        return MZ_STREAM_ERROR;
    if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))
        return MZ_PARAM_ERROR;

    pStream->data_type = 0;
    pStream->adler = 0;
    pStream->msg = NULL;
    pStream->total_in = 0;
    pStream->total_out = 0;
    pStream->reserved = 0;
    if (!pStream->zalloc)
        pStream->zalloc = miniz_def_alloc_func;
    if (!pStream->zfree)
        pStream->zfree = miniz_def_free_func;

    pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
    if (!pDecomp)
        return MZ_MEM_ERROR;

    pStream->state = (struct mz_internal_state *)pDecomp;

    tinfl_init(&pDecomp->m_decomp);
    pDecomp->m_dict_ofs = 0;
    pDecomp->m_dict_avail = 0;
    pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
    pDecomp->m_first_call = 1;
    pDecomp->m_has_flushed = 0;
    pDecomp->m_window_bits = window_bits;

    return MZ_OK;
}

// Assembly:
testq %rdi, %rdi
je 0xfdf08
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xf, %esi
je 0xfde8f
movl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
cmpl $-0xf, %ebx
jne 0xfdf0f
andl $0x0, 0x58(%r14)
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x60(%r14)
movq 0x40(%r14), %rax
testq %rax, %rax
jne 0xfdeba
leaq -0x109e(%rip), %rax     # 0xfce18
movq %rax, 0x40(%r14)
cmpq $0x0, 0x48(%r14)
jne 0xfdecc
leaq -0x10a4(%rip), %rcx     # 0xfce24
movq %rcx, 0x48(%r14)
movq 0x50(%r14), %rdi
pushq $0x1
popq %rsi
movl $0xa0d0, %edx           # imm = 0xA0D0
callq *%rax
testq %rax, %rax
je 0xfdf0c
movq %rax, 0x38(%r14)
andl $0x0, (%rax)
movl $0x1, 0xa0cc(%rax)
movaps 0x41fe9(%rip), %xmm0    # 0x13fee0
movups %xmm0, 0x20b8(%rax)
movl %ebx, 0x20c8(%rax)
xorl %eax, %eax
jmp 0xfdf0f
pushq $-0x2
popq %rax
retq
pushq $-0x4
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: mz_uncompress2
int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong *pSource_len)
{
    mz_stream stream;
    int status;
    memset(&stream, 0, sizeof(stream));

    /* In case mz_ulong is 64-bits (argh I hate longs). */
    if ((mz_uint64)(*pSource_len | *pDest_len) > 0xFFFFFFFFU)
        return MZ_PARAM_ERROR;

    stream.next_in = pSource;
    stream.avail_in = (mz_uint32)*pSource_len;
    stream.next_out = pDest;
    stream.avail_out = (mz_uint32)*pDest_len;

    status = mz_inflateInit(&stream);
    if (status != MZ_OK)
        return status;

    status = mz_inflate(&stream, MZ_FINISH);
    *pSource_len = *pSource_len - stream.avail_in;
    if (status != MZ_STREAM_END)
    {
        mz_inflateEnd(&stream);
        return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
    }
    *pDest_len = stream.total_out;

    return mz_inflateEnd(&stream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r14
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
andq $0x0, 0x70(%rsp)
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x10(%rsp)
movq (%rcx), %rsi
movq (%rbx), %rcx
movq %rcx, %rax
orq %rsi, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %r15d      # imm = 0xFFFFD8F0
jne 0xffccb
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movl %esi, 0x8(%rax)
movq %rdi, 0x18(%rax)
movl %ecx, 0x20(%rax)
movq %rax, %rdi
callq 0xfdf17
movl %eax, %r15d
testl %eax, %eax
jne 0xffccb
leaq 0x8(%rsp), %r15
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0xfdf5e
movl %eax, %ebp
movl 0x8(%r15), %eax
subq %rax, (%r14)
cmpl $0x1, %ebp
jne 0xffca5
movq 0x30(%rsp), %rax
movq %rax, (%rbx)
movq 0x40(%rsp), %rsi
xorl %r15d, %r15d
testq %rsi, %rsi
je 0xffccb
movq 0x58(%rsp), %rdi
callq *0x50(%rsp)
jmp 0xffccb
movq 0x40(%rsp), %rsi
testq %rsi, %rsi
je 0xffcbc
movq 0x58(%rsp), %rdi
callq *0x50(%rsp)
movl 0x10(%rsp), %eax
movl %ebp, %ecx
xorl $-0x5, %ecx
orl %eax, %ecx
pushq $-0x3
popq %r15
cmovnel %ebp, %r15d
movl %r15d, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tdefl_flush_output_buffer
static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
{
    if (d->m_pIn_buf_size)
    {
        *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
    }

    if (d->m_pOut_buf_size)
    {
        size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining);
        memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n);
        d->m_output_flush_ofs += (mz_uint)n;
        d->m_output_flush_remaining -= (mz_uint)n;
        d->m_out_buf_ofs += n;

        *d->m_pOut_buf_size = d->m_out_buf_ofs;
    }

    return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0xffd34
movq 0xb0(%rbx), %rcx
subq 0x88(%rbx), %rcx
movq %rcx, (%rax)
movq 0xa0(%rbx), %rax
testq %rax, %rax
je 0xffd94
movq (%rax), %r14
movq 0xc0(%rbx), %rdi
subq %rdi, %r14
movl 0x74(%rbx), %eax
cmpq %rax, %r14
cmovaeq %rax, %r14
movl 0x70(%rbx), %eax
addq 0x90(%rbx), %rdi
leaq (%rbx,%rax), %rsi
addq $0x392aa, %rsi          # imm = 0x392AA
movq %r14, %rdx
callq 0x181e0
addl %r14d, 0x70(%rbx)
subl %r14d, 0x74(%rbx)
addq 0xc0(%rbx), %r14
movq %r14, 0xc0(%rbx)
movq 0xa0(%rbx), %rax
movq %r14, (%rax)
cmpl $0x0, 0x78(%rbx)
je 0xffda5
xorl %eax, %eax
cmpl $0x0, 0x74(%rbx)
sete %al
jmp 0xffda7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tdefl_compress_mem_to_output
mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
    tdefl_compressor *pComp;
    mz_bool succeeded;
    if (((buf_len) && (!pBuf)) || (!pPut_buf_func))
        return MZ_FALSE;
    pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
    if (!pComp)
        return MZ_FALSE;
    succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
    succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
    MZ_FREE(pComp);
    return succeeded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
sete %cl
andb %al, %cl
testq %rdx, %rdx
sete %al
xorl %ebp, %ebp
orb %cl, %al
jne 0x1004b5
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movl %r8d, 0x4(%rsp)
movl $0x4df78, %edi          # imm = 0x4DF78
callq 0x18200
testq %rax, %rax
je 0x1004b5
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl 0x4(%rsp), %ecx
callq 0xfcfa4
pushq $0x4
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1003f6
xorl %ebp, %ebp
cmpl $0x1, %eax
sete %bpl
movq %r12, %rdi
callq 0x18030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tdefl_compress_mem_to_heap
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
    tdefl_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_len)
        return MZ_FALSE;
    else
        *pOut_len = 0;
    out_buf.m_expandable = MZ_TRUE;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return NULL;
    *pOut_len = out_buf.m_size;
    return out_buf.m_pBuf;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdx), %rdi
movq 0x8(%rdx), %r12
movslq %esi, %r15
leaq (%rdi,%r15), %r13
cmpq %r12, %r13
jbe 0x100578
xorl %ebp, %ebp
cmpl $0x0, 0x18(%rbx)
je 0x100590
movl $0x80, %eax
addq %r12, %r12
cmpq $0x81, %r12
cmovbq %rax, %r12
cmpq %r12, %r13
ja 0x100547
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x18250
testq %rax, %rax
je 0x100590
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
jmp 0x10057c
movq 0x10(%rbx), %rax
addq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x181e0
movq %r13, (%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tdefl_compress_mem_to_mem
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
{
    tdefl_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_buf)
        return 0;
    out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
    out_buf.m_capacity = out_buf_len;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return 0;
    return out_buf.m_size;
}

// Assembly:
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %rdi, %rdi
je 0x1005e3
movq %rsp, %rax
movq %rdi, 0x10(%rax)
movq %rsi, 0x8(%rax)
leaq -0xb2(%rip), %r9        # 0x100516
movq %rdx, %rdi
movq %rcx, %rsi
movq %r9, %rdx
movq %rax, %rcx
callq 0x100439
testl %eax, %eax
je 0x1005e3
movq (%rsp), %rax
jmp 0x1005e5
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tinfl_decompress_mem_to_heap
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
    tinfl_decompressor decomp;
    void *pBuf = NULL, *pNew_buf;
    size_t src_buf_ofs = 0, out_buf_capacity = 0;
    *pOut_len = 0;
    tinfl_init(&decomp);
    for (;;)
    {
        size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, &dst_buf_size,
                                               (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
        if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        src_buf_ofs += src_buf_size;
        *pOut_len += dst_buf_size;
        if (status == TINFL_STATUS_DONE)
            break;
        new_out_buf_capacity = out_buf_capacity * 2;
        if (new_out_buf_capacity < 128)
            new_out_buf_capacity = 128;
        pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
        if (!pNew_buf)
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        pBuf = pNew_buf;
        out_buf_capacity = new_out_buf_capacity;
    }
    return pBuf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20e8, %rsp           # imm = 0x20E8
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
andq $0x0, (%rdx)
leaq 0x30(%rsp), %rax
andl $0x0, (%rax)
andl $-0x7, %ebp
orl $0x4, %ebp
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x28(%rsp), %rax
subq %r15, %rax
movq %rax, 0x18(%rsp)
movq %r12, %rax
subq %r14, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
leaq (%rax,%r15), %rsi
addq %r13, %r14
testq %r13, %r13
cmoveq %r13, %r14
movl %ebp, (%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movq %r13, %rcx
movq %r14, %r8
leaq 0x10(%rsp), %r9
callq 0xfe299
testl %eax, %eax
js 0x1006c7
cmpl $0x1, %eax
je 0x1006c7
addq 0x18(%rsp), %r15
movq (%rbx), %r14
addq 0x10(%rsp), %r14
movq %r14, (%rbx)
testl %eax, %eax
je 0x1006d6
addq %r12, %r12
cmpq $0x81, %r12
movl $0x80, %eax
cmovbq %rax, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x18250
testq %rax, %rax
je 0x1006c7
movq %rax, %r13
jmp 0x100637
movq %r13, %rdi
callq 0x18030
andq $0x0, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x20e8, %rsp           # imm = 0x20E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tinfl_decompress_mem_to_callback
int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
    int result = 0;
    tinfl_decompressor decomp;
    mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
    size_t in_buf_ofs = 0, dict_ofs = 0;
    if (!pDict)
        return TINFL_STATUS_FAILED;
    memset(pDict,0,TINFL_LZ_DICT_SIZE);
    tinfl_init(&decomp);
    for (;;)
    {
        size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
                                               (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
        in_buf_ofs += in_buf_size;
        if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
            break;
        if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
        {
            result = (status == TINFL_STATUS_DONE);
            break;
        }
        dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
    }
    MZ_FREE(pDict);
    *pIn_buf_size = in_buf_ofs;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20f8, %rsp           # imm = 0x20F8
movl %r8d, %r15d
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x38(%rsp)
pushq $0x1
popq %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x18190
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x100830
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andl $-0x7, %r15d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
movq (%rax), %rax
subq %r13, %rax
movq %rax, 0x20(%rsp)
movl $0x8000, %eax           # imm = 0x8000
subq %rbp, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
leaq (%rax,%r13), %rsi
movq 0x8(%rsp), %rcx
leaq (%rcx,%rbp), %rbx
movl %r15d, %r14d
movl %r15d, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %r8
leaq 0x18(%rsp), %r9
callq 0xfe299
movl %eax, %r12d
addq 0x20(%rsp), %r13
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x10080a
movq %rbx, %rdi
movl %r15d, %esi
movq 0x30(%rsp), %rdx
callq *0x28(%rsp)
testl %eax, %eax
je 0x100835
cmpl $0x2, %r12d
jne 0x100825
addl %ebp, %r15d
andl $0x7fff, %r15d          # imm = 0x7FFF
movq %r15, %rbp
movl %r14d, %r15d
jmp 0x100798
xorl %ebp, %ebp
testl %r12d, %r12d
sete %bpl
jmp 0x100837
pushq $-0x1
popq %rbp
jmp 0x100849
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
callq 0x18030
movq 0x10(%rsp), %rax
movq %r13, (%rax)
movl %ebp, %eax
addq $0x20f8, %rsp           # imm = 0x20F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/../foreign/miniz-c.h
// Function: tinfl_decompressor_alloc
tinfl_decompressor *tinfl_decompressor_alloc(void)
{
    tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor));
    if (pDecomp)
        tinfl_init(pDecomp);
    return pDecomp;
}

// Assembly:
pushq %rax
movl $0x20b8, %edi           # imm = 0x20B8
callq 0x18200
testq %rax, %rax
je 0x100870
andl $0x0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-miniz.c
// Function: dfilter_deflate_codec_miniz
void dfilter_deflate_codec_miniz(struct de_dfilter_ctx *dfctx, void *codec_private_params)
{
	struct deflate_pushable_ctx *dc = NULL;
	struct de_deflate_params *deflparams = (struct de_deflate_params*)codec_private_params;

	dc = de_malloc(dfctx->c, sizeof(struct deflate_pushable_ctx));
	dc->modname = "deflate-mz";
	if(deflparams) {
		dc->flags = deflparams->flags;
	}

	dfctx->codec_private = (void*)dc;
	dfctx->codec_addbuf_fn = my_deflate_codec_addbuf;
	dfctx->codec_finish_fn = my_deflate_codec_finish;
	dfctx->codec_destroy_fn = my_deflate_codec_destroy;

	deflate_codec_init(dfctx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0xa0, %esi
callq 0xdecaf
movq %rax, %r15
leaq 0x3f801(%rip), %rcx     # 0x14009a
movq %rcx, 0x28(%rax)
testq %r14, %r14
je 0x1008aa
movl (%r14), %ecx
movl %ecx, (%r15)
jmp 0x1008ad
movl (%r15), %ecx
movq %r15, 0x28(%rbx)
leaq 0x8e(%rip), %rdx        # 0x100946
movq %rdx, 0x30(%rbx)
leaq 0x22f(%rip), %rdx       # 0x100af2
movq %rdx, 0x40(%rbx)
leaq 0x285(%rip), %rdx       # 0x100b53
movq %rdx, 0x48(%rbx)
movq (%rbx), %r14
movq 0x8(%rbx), %rdx
andq $0x0, 0x8(%rdx)
addq $0x30, %rax
leaq 0x143f(%rip), %rdx      # 0x101d28
movq %rdx, 0x70(%r15)
leaq 0x1439(%rip), %rdx      # 0x101d2d
movq %rdx, 0x78(%r15)
movq %r14, 0x80(%r15)
testb $0x1, %cl
jne 0x100911
pushq $-0xf
popq %rsi
movq %rax, %rdi
callq 0xfde6a
jmp 0x100919
movq %rax, %rdi
callq 0xfdf17
testl %eax, %eax
je 0x10093b
movq 0x8(%rbx), %rsi
movq 0x28(%r15), %rdx
leaq 0x3fa99(%rip), %rcx     # 0x1403c5
movq %r14, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xee823
movb $0x1, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-miniz.c
// Function: my_deflate_codec_finish
static void my_deflate_codec_finish(struct de_dfilter_ctx *dfctx)
{
	struct deflate_pushable_ctx *dc = (struct deflate_pushable_ctx*)dfctx->codec_private;

	if(dc->stream_open_flag) {
		if(!dfctx->dres->errcode) {
			de_dbgx(dfctx->c, 4, "inflated %u to %u bytes", (unsigned int)dc->strm.total_in,
				(unsigned int)dc->strm.total_out);
		}
		mz_inflateEnd(&dc->strm);
		dc->stream_open_flag = 0;
	}

	dfctx->dres->bytes_consumed = dc->total_nbytes_processed;
	dfctx->dres->bytes_consumed_valid = 1;
	dfctx->finished_flag = 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
cmpb $0x0, 0x4(%r14)
je 0x100b37
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
jne 0x100b29
movq (%rbx), %rdi
movl 0x40(%r14), %ecx
movl 0x58(%r14), %r8d
leaq 0x3f88e(%rip), %rdx     # 0x1403ad
pushq $0x4
popq %rsi
xorl %eax, %eax
callq 0xdeb15
leaq 0x30(%r14), %rdi
callq 0xffbc0
movb $0x0, 0x4(%r14)
movq 0x10(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movb $0x1, %al
movb %al, 0x4(%rcx)
movb %al, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-miniz.c
// Function: my_deflate_codec_destroy
static void my_deflate_codec_destroy(struct de_dfilter_ctx *dfctx)
{
	struct deflate_pushable_ctx *dc = (struct deflate_pushable_ctx*)dfctx->codec_private;
	deark *c = dfctx->c;

	if(dc) {
		de_free(c, dc->outbuf);
		de_free(c, dc);
	}
	dfctx->codec_private = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x100b7e
movq (%rbx), %r15
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0xded32
movq %r15, %rdi
movq %r14, %rsi
callq 0xded32
andq $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-miniz.c
// Function: fmtutil_tdefl_create
struct fmtutil_tdefl_ctx *fmtutil_tdefl_create(deark *c, dbuf *outf, int flags)
{
	struct fmtutil_tdefl_ctx *tdctx = NULL;

	tdctx = de_malloc(c, sizeof(struct fmtutil_tdefl_ctx));
	tdctx->c = c;
	tdefl_init(&tdctx->pComp, my_fmtutil_tdefl_output_buffer_putter, (void*)outf,
		flags);
	return tdctx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x4df80, %esi          # imm = 0x4DF80
callq 0xdecaf
movq %rax, %r12
movq %r15, (%rax)
leaq 0x8(%rax), %rdi
leaq 0x19(%rip), %rsi        # 0x100be8
movq %r14, %rdx
movl %ebx, %ecx
callq 0xfcfa4
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/fmtutil-miniz.c
// Function: fmtutil_tdefl_compress_buffer
enum fmtutil_tdefl_status fmtutil_tdefl_compress_buffer(struct fmtutil_tdefl_ctx *tdctx,
	const void *pIn_buf, size_t in_buf_size, enum fmtutil_tdefl_flush flush)
{
	tdefl_status st;

	st = tdefl_compress_buffer(&tdctx->pComp, pIn_buf, in_buf_size,
		fmtutil_flush_to_tdefl(flush));
	return tdefl_status_to_fmtutil(st);
}

// Assembly:
pushq %rax
addq $0x8, %rdi
leal -0x2(%rcx), %eax
xorl %r8d, %r8d
cmpl $0x3, %eax
cmovael %r8d, %ecx
callq 0x1003f6
leal 0x2(%rax), %ecx
cmpl $0x4, %ecx
pushq $-0x1
popq %rcx
cmovael %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-util2.c
// Function: de_decompress_zlib_mem2mem
int de_decompress_zlib_mem2mem(deark *c,
	const u8 *src, i64 src_len, u8 *dst, i64 dst_len)
{
	int retval = 0;
	dbuf *outf = NULL;
	struct de_dfilter_out_params dcmpro;
	struct de_dfilter_results dres;
	struct de_deflate_params inflparams;
	struct de_dfilter_ctx *dfctx = NULL;

	de_zeromem(&inflparams, sizeof(struct de_deflate_params));
	inflparams.flags = DE_DEFLATEFLAG_ISZLIB;

	de_dfilter_init_objects(c, NULL, &dcmpro, &dres);

	outf = dbuf_create_membuf(c, dst_len, 0x1);
	dbuf_enable_wbuffer(outf);

	dcmpro.f = outf;
	dcmpro.expected_len = dst_len;
	dcmpro.len_known = 1;

	dfctx = de_dfilter_create(c, dfilter_deflate_codec_miniz, (void*)&inflparams,
		&dcmpro, &dres);

	de_dfilter_addbuf(dfctx, src, src_len);
	de_dfilter_finish(dfctx);
	dbuf_flush(outf);
	if(dres.errcode==0) {
		retval = 1;
	}
	// TODO: There's too much copying. Could use a custom dbuf to
	// reduce the # of copies by 1.
	dbuf_read(outf, dst, 0, dst_len);

	de_dfilter_destroy(dfctx);
	dbuf_close(outf);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %rbx
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
movl $0x1, (%r12)
leaq 0x30(%rsp), %r13
leaq 0x48(%rsp), %rbp
xorl %esi, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0xee7ee
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe59cd
movq %rax, %r15
movq %rax, %rdi
callq 0xe589c
movq %r15, (%r13)
movq %rbx, 0x10(%r13)
movb $0x1, 0x8(%r13)
leaq -0x153c(%rip), %rsi     # 0x100877
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %rbp, %r12
callq 0xee930
movq %rax, %r14
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xee97f
movq %r14, %rdi
callq 0xee9d1
movq %r15, %rdi
callq 0xe58e8
xorl %ebp, %ebp
cmpl $0x0, (%r12)
sete %bpl
movq %r15, %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xe3cb7
movq %r14, %rdi
callq 0xee9dd
movq %r15, %rdi
callq 0xe5591
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-png.c
// Function: write_png_chunk_from_cdbuf
static void write_png_chunk_from_cdbuf(struct deark_png_encode_info *pei,
	dbuf *cdbuf, u32 chunktype)
{
	const u8 *mem;

	mem = dbuf_get_membuf_direct_ptr(cdbuf);
	if(mem==NULL && cdbuf->len!=0) goto done;
	write_png_chunk_from_mem(pei, mem, cdbuf->len, chunktype);

done:
	;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe62e4
movq %rax, %r14
movq 0x18(%r15), %r15
testq %rax, %rax
je 0x10282f
movq 0x70(%rbx), %rdi
callq 0xe0e44
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0xe5f65
movl %ebp, %esi
leaq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0xe5f60
movq 0x70(%rbx), %rdi
pushq $0x4
popq %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0xe0ecf
movq 0x8(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe46ba
movq 0x70(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe0ecf
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe46ba
movq 0x70(%rbx), %rdi
callq 0xe0e95
movq 0x8(%rbx), %rdi
movl %eax, %esi
callq 0xe5f65
jmp 0x102834
testq %r15, %r15
je 0x102843
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x1027b5
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-png.c
// Function: my_IDAT_write_cb
static void my_IDAT_write_cb(dbuf *f, void *userdata,
	const u8 *mem_orig, i64 memsize_orig)
{
	struct IDAT_write_userdata_struct *iwu = (struct IDAT_write_userdata_struct*)userdata;
	const u8 *mem = mem_orig;
	i64 memsize = memsize_orig;

	// We *could* just write a single IDAT chunk for each call to this function.
	// We would get a PNG with IDATs having various random-ish sizes.
	// I want the PNG output to be more predictable and stable than that, though,
	// so we'll do some buffering to make each chunk (except the last) have
	// DE_MAX_IDAT_CHUNKSIZE bytes.

	while(iwu->cdbuf->len + memsize >= DE_MAX_IDAT_CHUNKSIZE) {
		i64 amt_to_use_from_membuf;

		if(iwu->cdbuf->len >= DE_MAX_IDAT_CHUNKSIZE) {
			amt_to_use_from_membuf = 0;
		}
		else {
			amt_to_use_from_membuf = DE_MAX_IDAT_CHUNKSIZE - iwu->cdbuf->len;
		}

		dbuf_write(iwu->cdbuf, mem, amt_to_use_from_membuf);
		mem += amt_to_use_from_membuf;
		memsize -= amt_to_use_from_membuf;
		// cdbuf should now have exactly DE_MAX_IDAT_CHUNKSIZE bytes in it.

		write_png_chunk_from_cdbuf(iwu->pei, iwu->cdbuf, CODE_IDAT);
		iwu->IDAT_count++;
		dbuf_empty(iwu->cdbuf);
	}

	// Save any remaining compressed pixel data for next time.
	if(memsize > 0) {
		dbuf_write(iwu->cdbuf, mem, memsize);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
movq 0x8(%r15), %rdi
movq 0x18(%rdi), %rax
leaq (%rax,%rbx), %rcx
cmpq $0x100000, %rcx         # imm = 0x100000
jl 0x1028ba
leaq -0x100000(%rax), %r12
negq %r12
cmpq $0x100000, %rax         # imm = 0x100000
cmovgeq %r13, %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0xe46ba
addq %r12, %r14
subq %r12, %rbx
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movl $0x49444154, %edx       # imm = 0x49444154
callq 0x10278e
incl 0x10(%r15)
movq 0x8(%r15), %rdi
callq 0xe62cf
jmp 0x102860
testq %rbx, %rbx
jle 0x1028d3
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe46ba
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/OhYee[P]computer_application_programming_experiment/utils/bits/test/test_bits.c
// Function: main
int main() {
    mp_init(1 << 30, mp_exit);
    boolean pass = T;
    int     prefix;

    // 0110 1001  1100 0011
    bits *b = bits_init_with_minimum_bytes("\x69\xC3", 0, 16);
    bits *s1 = bits_sub(b, 4, 12); // 0011 0110
    bits *s2 = bits_sub(b, 3, 5);  // 0011 0110

    if ((prefix = bits_prefix(b, s1, 1)) != 0) {
        print_err("prefix want 0, got %d\n", prefix);
        pass = F;
    }

    if ((prefix = bits_prefix(b, s1, 1)) != 0) {
        print_err("prefix want 0, got %d\n", prefix);
        pass = F;
    }

    if ((prefix = bits_prefix(b, s2, 1)) != 2) {
        print_err("prefix want 2, got %d\n", prefix);
        pass = F;
    }

    if (pass) {
        print_ok("All testcases passed.\n");
    } else {
        print_err("Some errors!\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq -0x772(%rip), %rsi      # 0x118c
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x1195
leaq 0x88d(%rip), %rdi       # 0x219c
pushq $0x10
popq %rdx
xorl %esi, %esi
callq 0x1426
movq %rax, %rbx
pushq $0x4
popq %rsi
pushq $0xc
popq %rdx
movq %rax, %rdi
callq 0x1546
movq %rax, %r15
pushq $0x3
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x1546
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15da
testl %eax, %eax
je 0x1969
leaq 0x848(%rip), %rdi       # 0x219f
movl %eax, %esi
xorl %eax, %eax
callq 0x1780
leaq 0x831(%rip), %rax       # 0x2198
jmp 0x1970
leaq 0x824(%rip), %rax       # 0x2194
movl (%rax), %ebp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15da
testl %eax, %eax
je 0x199d
leaq 0x814(%rip), %rdi       # 0x219f
movl %eax, %esi
xorl %eax, %eax
callq 0x1780
leaq 0x7fd(%rip), %rax       # 0x2198
movl (%rax), %ebp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15da
cmpl $0x2, %eax
je 0x19c9
leaq 0x7ff(%rip), %rdi       # 0x21b6
movl %eax, %esi
xorl %eax, %eax
callq 0x1780
leaq 0x7d1(%rip), %rax       # 0x2198
movl (%rax), %ebp
testl %ebp, %ebp
je 0x19dd
leaq 0x7f9(%rip), %rdi       # 0x21cd
xorl %eax, %eax
callq 0x1838
jmp 0x19eb
leaq 0x800(%rip), %rdi       # 0x21e4
xorl %eax, %eax
callq 0x1780
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb-c-mp.c
// Function: test_int
int test_int(int n)
{
	int i, cnt = 0;
	uint64_t x = 11;
	intmap_t *d, *r;
	struct rb_table *h;
	kmempool_t(node) *mp;

	mp = kmp_init(node);
	h = rb_create(int_cmp, 0, 0);
	for (i = 0; i < n; ++i) {
		unsigned y = x % (n>>1);
		x = kad_splitmix64(x);
		d = kmp_alloc(node, mp);
		d->key = y; d->value = i;
		if (rb_find(h, d) == 0) {
			rb_insert(h, d);
			++cnt;
		} else {
			r = rb_delete(h, d);
			kmp_free(node, mp, d);
			kmp_free(node, mp, r);
			--cnt;
		}
	}
	rb_destroy(h, 0);
	kmp_destroy(node, mp);
	return cnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x1050
movq %rax, %rbx
leaq -0x32(%rip), %rdi       # 0x2258
xorl %r13d, %r13d
xorl %esi, %esi
xorl %edx, %edx
callq 0x11ac
movq %rax, 0x8(%rsp)
movl %ebp, %eax
sarl %eax
cltq
movq %rax, 0x10(%rsp)
testl %ebp, %ebp
cmovlel %r13d, %ebp
movl %ebp, 0x4(%rsp)
pushq $0xb
popq %r15
xorl %r14d, %r14d
cmpl %r14d, 0x4(%rsp)
je 0x23a4
movq %r13, %r12
movq %r15, %rax
xorl %edx, %edx
divq 0x10(%rsp)
movq %rdx, %rbp
incq (%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x22f1
movq 0x18(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq -0x8(%rcx,%rax,8), %r13
jmp 0x22ff
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x1050
movq %rax, %r13
movl %ebp, (%r13)
movl %r14d, 0x4(%r13)
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1212
movq %rbp, %rdi
testq %rax, %rax
je 0x2344
movq %r13, %rsi
callq 0x14af
movq %rax, %rbp
movq %rbx, %rdi
movq %r13, %rsi
callq 0x23f0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x23f0
pushq $-0x1
jmp 0x234e
movq %r13, %rsi
callq 0x146d
pushq $0x1
popq %rax
movabsq $-0x61c8864680b583eb, %rcx # imm = 0x9E3779B97F4A7C15
addq %rcx, %r15
movq %r15, %rcx
shrq $0x1e, %rcx
xorq %r15, %rcx
movabsq $-0x40a7b892e31b1a47, %rdx # imm = 0xBF58476D1CE4E5B9
imulq %rdx, %rcx
movq %rcx, %rdx
shrq $0x1b, %rdx
xorq %rcx, %rdx
movabsq $-0x6b2fb644ecceee15, %rcx # imm = 0x94D049BB133111EB
imulq %rcx, %rdx
movq %rdx, %r15
shrq $0x1f, %r15
xorq %rdx, %r15
movq %r12, %r13
addl %eax, %r13d
incl %r14d
jmp 0x22b7
xorl %r14d, %r14d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2101
movq 0x8(%rbx), %r12
movq 0x18(%rbx), %r15
cmpq %r14, %r12
je 0x23ce
movq (%r15,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x23bb
movq %r15, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aligrudi[P]gpss/gpss.c
// Function: report
static void report(int *S, int n)
{
	char mark[NPT] = {0};
	int i;
	for (i = 0; i < n; i++)
		mark[S[i]] = 1;
	printf("%d", pt_n - n);
	for (i = 0; i < pt_n; i++)
		if (!mark[i])
			printf(" %d", i);
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2710, %rsp           # imm = 0x2710
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %rdi
xorl %r15d, %r15d
movl $0x2710, %edx           # imm = 0x2710
xorl %esi, %esi
callq 0x1070
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
cmpq %r15, %rax
je 0x1c99
movslq (%r14,%r15,4), %rcx
movb $0x1, (%rsp,%rcx)
incq %r15
jmp 0x1c87
movl 0x33d1(%rip), %esi      # 0x5070
subl %ebx, %esi
leaq 0x138a(%rip), %rdi      # 0x3032
xorl %eax, %eax
callq 0x1060
movl 0x33bb(%rip), %eax      # 0x5070
leaq 0x1375(%rip), %rbx      # 0x3031
xorl %r14d, %r14d
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x1ce6
cmpb $0x0, (%rsp,%r14)
jne 0x1ce1
movq %rbx, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1060
movl 0x338f(%rip), %eax      # 0x5070
incq %r14
jmp 0x1cbf
pushq $0xa
popq %rdi
addq $0x2710, %rsp           # imm = 0x2710
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/saulvargas[P]re-C-sys/test_recdata.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    
    fclose(user_data);
    fclose(item_data);
    
    recdata_close(recdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
leaq 0x4(%rsp), %r10
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
pushq %rax
pushq %r10
callq 0x23bc
popq %rcx
popq %rdx
testl %eax, %eax
je 0x126e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
movl (%rsp), %r9d
callq 0x15ba
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x12b0
xorl %eax, %eax
jmp 0x1271
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/saulvargas[P]re-C-sys/recdata_simple.c
// Function: recdata_simple_close
void recdata_simple_close(void* args) {
    recdata_simple_args_t* a = args;
    
    free(a->n_userdata);
    free(a->i_userdata[0]);
    free(a->i_userdata);
    if (!a->binary) {
        free(a->r_userdata[0]);
        free(a->r_userdata);
    }
    free(a->n_itemdata);
    free(a->i_itemdata[0]);
    free(a->i_itemdata);
    if (!a->binary) {
        free(a->r_itemdata[0]);
        free(a->r_itemdata);
    }
    free(a);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
cmpl $0x0, 0x30(%rbx)
jne 0x1372
movq 0x10(%rbx), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x20(%rbx), %rdi
callq 0x1030
cmpl $0x0, 0x30(%rbx)
jne 0x13ab
movq 0x28(%rbx), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x28(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
jmp 0x1030