LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: clear
void clear(Queue q)
{
    assert(q!=NULL);
    q->size=0;
    q->front=1;
    q->end=0;
}

// Assembly:
testq %rdi, %rdi
je 0x11d3
andl $0x0, 0xc(%rdi)
movq $0x1, 0x4(%rdi)
retq
pushq %rax
leaq 0xe29(%rip), %rdi       # 0x2004
leaq 0xe2a(%rip), %rsi       # 0x200c
leaq 0xe2b(%rip), %rcx       # 0x2014
pushq $0x2c
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: create
Queue create(int maxSize)
{
    Queue q;
    q=(Queue)malloc(sizeof(struct QueueRecord));
    if(q==NULL)
    {
        fatal("queue malloc failed.");
    }
    q->data=malloc(sizeof(int)*maxSize);
    q->capacity=maxSize;
    if(q->data==NULL)
    {
        fatal("data array malloc failed.");
    }
    clear(q);
    return q;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
pushq $0x18
popq %rdi
callq 0x1080
testq %rax, %rax
je 0x1237
movq %rax, %rbx
movslq %ebp, %r14
leaq (,%r14,4), %rdi
callq 0x1080
movq %rax, 0x10(%rbx)
movl %r14d, (%rbx)
testq %rax, %rax
je 0x1243
andl $0x0, 0xc(%rbx)
movq $0x1, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xde8(%rip), %rdi       # 0x2026
callq 0x119c
leaq 0xdf1(%rip), %rdi       # 0x203b
callq 0x119c
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: print
void print(Queue q)
{
    assert(q!=NULL);
    if(isEmpty(q))
    {
        printf("queue is empty.\n");
        return;
    }
    for(int i=q->front; i<(q->front+q->size); i++)
    {

        int cursor=i;
        if(cursor>=q->capacity)
        {
            cursor=i-q->capacity;
        }
        printf("%d ", q->data[cursor]);
    }

    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1309
movq %rdi, %rbx
movl 0xc(%rdi), %eax
testl %eax, %eax
je 0x12f3
movl 0x4(%rbx), %ecx
movslq %ecx, %r15
xorl %ebp, %ebp
leaq 0xdcf(%rip), %r14       # 0x207b
addl %ecx, %eax
cmpl %eax, %r15d
jge 0x12e1
movl (%rbx), %eax
cmpl %eax, %r15d
cmovll %ebp, %eax
movq 0x10(%rbx), %rcx
cltq
shlq $0x2, %rax
subq %rax, %rcx
movl (%rcx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
movl 0x4(%rbx), %ecx
movl 0xc(%rbx), %eax
incq %r15
jmp 0x12ac
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1040
leaq 0xdef(%rip), %rdi       # 0x20e9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1050
leaq 0xcf4(%rip), %rdi       # 0x2004
leaq 0xcf5(%rip), %rsi       # 0x200c
leaq 0xd4b(%rip), %rcx       # 0x2069
pushq $0x4d
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: enqueue
void enqueue(int value, Queue q)
{
    assert(q!=NULL);
    if(isFull(q))
    {
        fatal("queue is full.");
    }
    q->size++;
    if(++q->end==q->capacity)
    {
        q->end=0;
    }
    q->data[q->end]=value;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1355
movl (%rsi), %eax
movl 0xc(%rsi), %ecx
cmpl %eax, %ecx
je 0x1372
incl %ecx
movl %ecx, 0xc(%rsi)
movl 0x8(%rsi), %ecx
incl %ecx
xorl %edx, %edx
cmpl %eax, %ecx
cmovnel %ecx, %edx
movl %edx, 0x8(%rsi)
movq 0x10(%rsi), %rax
movslq %edx, %rcx
movl %edi, (%rax,%rcx,4)
popq %rax
retq
leaq 0xca8(%rip), %rdi       # 0x2004
leaq 0xca9(%rip), %rsi       # 0x200c
leaq 0xd15(%rip), %rcx       # 0x207f
pushq $0x63
popq %rdx
callq 0x1070
leaq 0xd1f(%rip), %rdi       # 0x2098
callq 0x119c
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: dequeue
int dequeue(Queue q)
{
    assert(q!=NULL);
    if(isEmpty(q))
    {
        fatal("queue is empty.");
    }
    q->size--;
    int tmp= q->data[q->front];
    if(++q->front==q->capacity)
    {
        q->front=0;
    }
    return tmp;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13a9
movl 0xc(%rdi), %eax
testl %eax, %eax
je 0x13c6
decl %eax
movl %eax, 0xc(%rdi)
movq 0x10(%rdi), %rax
movslq 0x4(%rdi), %rcx
movl (%rax,%rcx,4), %eax
incl %ecx
xorl %edx, %edx
cmpl (%rdi), %ecx
cmovnel %ecx, %edx
movl %edx, 0x4(%rdi)
popq %rcx
retq
leaq 0xc54(%rip), %rdi       # 0x2004
leaq 0xc55(%rip), %rsi       # 0x200c
leaq 0xce9(%rip), %rcx       # 0x20a7
pushq $0x72
popq %rdx
callq 0x1070
leaq 0xd1c(%rip), %rdi       # 0x20e9
callq 0x119c
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: main
int main(int argc, char **argv)
{
    Queue q=create(10);
    for(int i=0; i<10; i++)
    {
        enqueue(i, q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    for(int i=0; i<8; i++)
    {
        dequeue(q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    for(int i=0; i<7; i++)
    {
        enqueue(-i,q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    for(int i=0; i<6; i++)
    {
        dequeue(q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    clear(q);
    print(q);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
pushq $0xa
popq %rdi
callq 0x11f1
movq %rax, %rbx
xorl %ebp, %ebp
cmpl $0xa, %ebp
je 0x142e
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1326
movq %rbx, %rdi
callq 0x1287
incl %ebp
jmp 0x1413
movq %rbx, %rdi
callq 0x14e2
leaq 0xcbc(%rip), %rdi       # 0x20f9
callq 0x1050
pushq $0x8
popq %rbp
movq %rbx, %rdi
subl $0x1, %ebp
jb 0x145c
callq 0x137e
movq %rbx, %rdi
callq 0x1287
jmp 0x1445
callq 0x14e2
leaq 0xc91(%rip), %rdi       # 0x20f9
callq 0x1050
xorl %ebp, %ebp
cmpl $-0x7, %ebp
je 0x148a
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1326
movq %rbx, %rdi
callq 0x1287
decl %ebp
jmp 0x146f
movq %rbx, %rdi
callq 0x14e2
leaq 0xc60(%rip), %rdi       # 0x20f9
callq 0x1050
pushq $0x6
popq %rbp
movq %rbx, %rdi
subl $0x1, %ebp
jb 0x14b8
callq 0x137e
movq %rbx, %rdi
callq 0x1287
jmp 0x14a1
callq 0x14e2
leaq 0xc35(%rip), %rdi       # 0x20f9
callq 0x1050
movq %rbx, %rdi
callq 0x11c1
movq %rbx, %rdi
callq 0x1287
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/mini_gzip.c
// Function: mini_gz_start
int
mini_gz_start(struct mini_gzip *gz_ptr, void *mem, size_t mem_len)
{
	uint8_t		*hptr, *hauxptr, *mem8_ptr;
	uint16_t	fextra_len;

	assert(gz_ptr != NULL);

	mem8_ptr = (uint8_t *)mem;
	hptr = mem8_ptr + 0;		// .gz header
	hauxptr = mem8_ptr + 10;	// auxillary header

	gz_ptr->hdr_ptr = hptr;
	gz_ptr->data_ptr = 0;
	gz_ptr->data_len = 0;
	gz_ptr->total_len = mem_len;
	gz_ptr->chunk_size = 1024;

	if (hptr[0] != 0x1F || hptr[1] != 0x8B) {
		GZDBG("hptr[0] = %02x hptr[1] = %02x\n", hptr[0], hptr[1]);
		return (-1);
	}
	if (hptr[2] != 8) {
		return (-2);
	}
	if (hptr[3] & 0x4) {
		fextra_len = hauxptr[1] << 8 | hauxptr[0];
		gz_ptr->fextra_len = fextra_len;
		hauxptr += 2;
		gz_ptr->fextra_ptr = hauxptr;
	}
	if (hptr[3] & 0x8) {
		gz_ptr->fname_ptr = hauxptr;
		while (*hauxptr != '\0') {
			hauxptr++;
		}
		hauxptr++;
	}
	if (hptr[3] & 0x10) {
		gz_ptr->fcomment_ptr = hauxptr;
		while (*hauxptr != '\0') {
			hauxptr++;
		}
		hauxptr++;
	}
	if (hptr[3] & 0x2) /* FCRC */ {
		gz_ptr->fcrc = (*(uint16_t *)hauxptr);
		hauxptr += 2;
	}
	gz_ptr->data_ptr = hauxptr;
	gz_ptr->data_len = mem_len - (hauxptr - hptr);
	gz_ptr->magic = MINI_GZIP_MAGIC;
	return (0);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1300
movq %rsi, 0x20(%rdi)
andq $0x0, 0x40(%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, (%rdi)
movq $0x400, 0x10(%rdi)      # imm = 0x400
pushq $-0x1
popq %rax
cmpb $0x1f, (%rsi)
jne 0x12fe
cmpb $-0x75, 0x1(%rsi)
jne 0x12fe
cmpb $0x8, 0x2(%rsi)
jne 0x1295
movb 0x3(%rsi), %cl
testb $0x4, %cl
jne 0x129a
leaq 0xa(%rsi), %rax
jmp 0x12ad
pushq $-0x2
popq %rax
jmp 0x12fe
movzwl 0xa(%rsi), %eax
movw %ax, 0x1e(%rdi)
leaq 0xc(%rsi), %rax
movq %rax, 0x28(%rdi)
movb 0x3(%rsi), %cl
testb $0x8, %cl
je 0x12c2
movq %rax, 0x30(%rdi)
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x12b6
movb 0x3(%rsi), %cl
testb $0x10, %cl
je 0x12d7
movq %rax, 0x38(%rdi)
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x12cb
movb 0x3(%rsi), %cl
testb $0x2, %cl
je 0x12e7
movzwl (%rax), %ecx
movw %cx, 0x1c(%rdi)
addq $0x2, %rax
movq %rax, 0x40(%rdi)
addq %rdx, %rsi
subq %rax, %rsi
movq %rsi, 0x8(%rdi)
movl $0xbeebb00b, 0x18(%rdi) # imm = 0xBEEBB00B
xorl %eax, %eax
popq %rcx
retq
leaq 0x5cfd(%rip), %rdi      # 0x7004
leaq 0x5d05(%rip), %rsi      # 0x7013
leaq 0x5d0a(%rip), %rcx      # 0x701f
pushq $0x1e
popq %rdx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/mini_gzip.c
// Function: mini_gz_unpack
int
mini_gz_unpack(struct mini_gzip *gz_ptr, void *mem_out, size_t mem_out_len)
{
	z_stream s;
	int	ret, in_bytes_avail, bytes_to_read;

	assert(gz_ptr != 0);
	assert(gz_ptr->data_len > 0);
	assert(gz_ptr->magic == MINI_GZIP_MAGIC);

	memset (&s, 0, sizeof (z_stream));
	inflateInit2(&s, -MZ_DEFAULT_WINDOW_BITS);
	in_bytes_avail = gz_ptr->data_len;
	s.avail_out = mem_out_len;
	s.next_in = gz_ptr->data_ptr;
	s.next_out = mem_out;
	for (;;) {
		bytes_to_read = MINI_GZ_MIN(gz_ptr->chunk_size, in_bytes_avail);
		s.avail_in += bytes_to_read;
		ret = mz_inflate(&s, MZ_SYNC_FLUSH);
		in_bytes_avail -= bytes_to_read;
		if (s.avail_out == 0 && in_bytes_avail != 0) {
			return (-3);
		}
		assert(ret != MZ_BUF_ERROR);
		if (ret == MZ_PARAM_ERROR) {
			return (-1);
		}
		if (ret == MZ_DATA_ERROR) {
			return (-2);
		}
		if (ret == MZ_STREAM_END) {
			break;
		}
	}
	ret = inflateEnd(&s);
	if (ret != Z_OK) {
		return (-4);
	}
	return (s.total_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
je 0x14b0
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x14c9
cmpl $0xbeebb00b, 0x18(%rbx) # imm = 0xBEEBB00B
jne 0x14e2
movq %rdx, %r12
movq %rsi, %r15
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
andq $0x0, 0x70(%r14)
pushq $-0xf
popq %rsi
movq %r14, %rdi
callq 0x2da4
movl 0x8(%rbx), %r13d
movl %r12d, 0x20(%r14)
movq 0x40(%rbx), %rax
movq %rax, (%r14)
movq %r15, 0x18(%r14)
pushq $0x2
popq %r15
pushq $-0x3
popq %rbp
movq 0x10(%rbx), %r12
movslq %r13d, %r13
cmpq %r13, %r12
cmovael %r13d, %r12d
addl %r12d, 0x8(%rsp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e5e
subl %r12d, %r13d
cmpl $0x0, 0x20(%rsp)
jne 0x144f
testl %r13d, %r13d
jne 0x1499
cmpl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
je 0x1486
cmpl $-0x3, %eax
je 0x1482
cmpl $0x1, %eax
je 0x148a
cmpl $-0x5, %eax
jne 0x1422
leaq 0x5c96(%rip), %rdi      # 0x7102
leaq 0x5ba0(%rip), %rsi      # 0x7013
leaq 0x5c3c(%rip), %rcx      # 0x70b6
pushq $0x7a
popq %rdx
callq 0x1090
pushq $-0x2
jmp 0x1498
pushq $-0x1
jmp 0x1498
movq %rsp, %rdi
callq 0x4b17
testl %eax, %eax
je 0x14aa
pushq $-0x4
popq %rbp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%rsp), %ebp
jmp 0x1499
leaq 0x5b9e(%rip), %rdi      # 0x7055
leaq 0x5b55(%rip), %rsi      # 0x7013
leaq 0x5bf1(%rip), %rcx      # 0x70b6
pushq $0x68
jmp 0x147c
leaq 0x5c1d(%rip), %rdi      # 0x70ed
leaq 0x5b3c(%rip), %rsi      # 0x7013
leaq 0x5bd8(%rip), %rcx      # 0x70b6
pushq $0x69
jmp 0x147c
leaq 0x5bac(%rip), %rdi      # 0x7095
leaq 0x5b23(%rip), %rsi      # 0x7013
leaq 0x5bbf(%rip), %rcx      # 0x70b6
pushq $0x6a
jmp 0x147c
nop
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 0x17f3
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 0x17ea
xorl %r11d, %r11d
leal 0x7(%r11), %eax
cmpl %r8d, %eax
jae 0x17c0
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 0x1749
movzbl (%rsi,%r11), %eax
addl %eax, %r9d
addl %r9d, %r10d
incq %r11
cmpl %r8d, %r11d
jb 0x17b2
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 0x173d
shll $0x10, %r10d
orl %r9d, %r10d
jmp 0x17f7
pushq $0x1
popq %r10
movq %r10, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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_COMPUTE_CRC32 | 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->crc32 = MZ_CRC32_INIT;
  pStream->msg = NULL;
  pStream->reserved = 0;
  pStream->total_in = 0;
  pStream->total_out = 0;
  if (!pStream->zalloc) pStream->zalloc = def_alloc_func;
  if (!pStream->zfree) pStream->zfree = 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 0x1947
testq %rbx, %rbx
je 0x1933
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 0x1937
cmpl $0xf, %r15d
je 0x18c1
cmpl $-0xf, %r15d
jne 0x1937
andl $0x0, 0x58(%rbx)
movq $0x1, 0x60(%rbx)
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x68(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x18f1
leaq 0xcb(%rip), %rax        # 0x19b8
movq %rax, 0x40(%rbx)
cmpq $0x0, 0x48(%rbx)
jne 0x1903
leaq 0xc5(%rip), %rcx        # 0x19c4
movq %rcx, 0x48(%rbx)
movq 0x50(%rbx), %rdi
pushq $0x1
popq %rsi
movl $0x4df80, %edx          # imm = 0x4DF80
callq *%rax
testq %rax, %rax
je 0x1943
orl $0x6000, %ebp           # imm = 0x6000
movq %rax, 0x38(%rbx)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x19cc
jmp 0x1937
pushq $-0x2
popq %r14
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x4
jmp 0x1935
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 0x5bb1(%rip), %rax      # 0x7510
xorl %r8d, %r8d
cmpl $0x4, %edi
setl %r8b
shll $0xf, %r8d
orl (%rax,%rcx,4), %r8d
movl %r8d, %eax
orl $0x1000, %eax           # imm = 0x1000
testl %esi, %esi
cmovlel %r8d, %eax
testl %edi, %edi
je 0x19a0
decl %edx
cmpl $0x3, %edx
ja 0x19ab
leaq 0x583f(%rip), %rcx      # 0x71d0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
orl $0x40000, %eax          # imm = 0x40000
retq
orl $0x100000, %eax         # imm = 0x100000
retq
orl $0x20000, %eax          # imm = 0x20000
retq
orl $0x80000, %eax          # imm = 0x80000
retq
andl $0xfffff000, %eax       # imm = 0xFFFFF000
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_init
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
  d->m_pPut_buf_func = pPut_buf_func; d->m_pPut_buf_user = pPut_buf_user;
  d->m_flags = (mz_uint)(flags); d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
  d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
  if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) MZ_CLEAR_OBJ(d->m_hash);
  d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0;
  d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0;
  d->m_pLZ_code_buf = d->m_lz_code_buf + 1; d->m_pLZ_flags = d->m_lz_code_buf; d->m_num_flags_left = 8;
  d->m_pOutput_buf = d->m_output_buf; d->m_pOutput_buf_end = d->m_output_buf; d->m_prev_return_status = TDEFL_STATUS_OKAY;
  d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; d->m_adler32 = 1; d->m_crc32 = 1;
  d->m_pIn_buf = NULL; d->m_pOut_buf = NULL;
  d->m_pIn_buf_size = NULL; d->m_pOut_buf_size = NULL;
  d->m_flush = TDEFL_NO_FLUSH; d->m_pSrc = NULL; d->m_src_buf_left = 0; d->m_out_buf_ofs = 0;
  memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
  memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
  return TDEFL_STATUS_OKAY;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movl %ecx, 0x10(%rdi)
movl %ecx, %esi
andl $0xfff, %esi            # imm = 0xFFF
leal 0x2(%rsi), %eax
movw $0x3, %di
xorl %edx, %edx
divw %di
incl %eax
movl $0xffff, %r8d           # imm = 0xFFFF
andl %r8d, %eax
movl %eax, 0x14(%rbx)
movl %ecx, %eax
shrl $0xf, %eax
andl $0x1, %eax
movl %eax, 0x1c(%rbx)
shrl $0x2, %esi
addl $0x2, %esi
movl %esi, %eax
xorl %edx, %edx
divw %di
incl %eax
andl %r8d, %eax
movl %eax, 0x18(%rbx)
btl $0x10, %ecx
jb 0x1a35
leaq 0x292b2(%rbx), %rdi
movl $0x10000, %edx          # imm = 0x10000
xorl %esi, %esi
callq 0x10a0
andl $0x0, 0x30(%rbx)
leaq 0x92b2(%rbx), %rax
leaq 0x92b3(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x5c(%rbx)
movups %xmm0, 0x78(%rbx)
andq $0x0, 0x88(%rbx)
movq %rcx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movl $0x8, 0x58(%rbx)
leaq 0x392b2(%rbx), %rax
movq %rax, 0x48(%rbx)
movq %rax, 0x50(%rbx)
andl $0x0, 0x74(%rbx)
andq $0x0, 0x6c(%rbx)
movsd 0x6347(%rip), %xmm1     # 0x7dd0
movups %xmm1, 0x20(%rbx)
leaq 0x81d2(%rbx), %rdi
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
andl $0x0, 0xb0(%rbx)
movups %xmm0, 0xb8(%rbx)
andq $0x0, 0xc8(%rbx)
movl $0x280, %edx            # imm = 0x280
xorl %esi, %esi
callq 0x10a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 0x1aee
movq %rdi, %r14
movq 0x38(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x1af1
movq 0x50(%r14), %rdi
callq *0x48(%r14)
andq $0x0, 0x38(%r14)
jmp 0x1af1
pushq $-0x2
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 0x1b36
movq %rdi, %rax
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x1b36
cmpq $0x0, 0x40(%rax)
je 0x1b36
cmpq $0x0, 0x48(%rax)
je 0x1b36
andq $0x0, 0x28(%rax)
andq $0x0, 0x10(%rax)
movl 0x10(%rdi), %ecx
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x19cc
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 ((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 $0x80, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x10(%rsp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %ebp       # imm = 0xFFFFD8F0
jne 0x2d55
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movq %rdi, 0x18(%rax)
movl %esi, 0x20(%rax)
movq %rax, %rdi
movl %r8d, %esi
callq 0x1858
movl %eax, %ebp
testl %eax, %eax
jne 0x2d55
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x1b3a
cmpl $0x1, %eax
jne 0x2d35
movq 0x30(%rsp), %rax
movq %rax, (%rbx)
movq 0x40(%rsp), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x2d55
movq 0x58(%rsp), %rdi
callq *0x50(%rsp)
jmp 0x2d55
movl %eax, %r14d
movq 0x40(%rsp), %rsi
testq %rsi, %rsi
je 0x2d4b
movq 0x58(%rsp), %rdi
callq *0x50(%rsp)
testl %r14d, %r14d
pushq $-0x5
popq %rbp
cmovnel %r14d, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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->crc32 = 0;
  pStream->msg = NULL;
  pStream->total_in = 0;
  pStream->total_out = 0;
  pStream->reserved = 0;
  if (!pStream->zalloc) pStream->zalloc = def_alloc_func;
  if (!pStream->zfree) pStream->zfree = 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 0x2e47
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xf, %esi
je 0x2dc9
movl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
cmpl $-0xf, %ebx
jne 0x2e4e
andl $0x0, 0x58(%r14)
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
andq $0x0, 0x70(%r14)
movups %xmm0, 0x60(%r14)
movq 0x40(%r14), %rax
testq %rax, %rax
jne 0x2df9
leaq -0x143d(%rip), %rax     # 0x19b8
movq %rax, 0x40(%r14)
cmpq $0x0, 0x48(%r14)
jne 0x2e0b
leaq -0x1443(%rip), %rcx     # 0x19c4
movq %rcx, 0x48(%r14)
movq 0x50(%r14), %rdi
pushq $0x1
popq %rsi
movl $0xab18, %edx           # imm = 0xAB18
callq *%rax
testq %rax, %rax
je 0x2e4b
movq %rax, 0x38(%r14)
andl $0x0, (%rax)
movl $0x1, 0xab14(%rax)
movaps 0x4fba(%rip), %xmm0     # 0x7df0
movups %xmm0, 0x2b00(%rax)
movl %ebx, 0x2b10(%rax)
xorl %eax, %eax
jmp 0x2e4e
pushq $-0x2
popq %rax
retq
pushq $-0x4
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// Function: mz_uncompress
int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
{
  mz_stream stream;
  int status;
  memset(&stream, 0, sizeof(stream));

  // In case mz_ulong is 64-bits (argh I hate longs).
  if ((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_inflateInit(&stream);
  if (status != MZ_OK)
    return status;

  status = mz_inflate(&stream, MZ_FINISH);
  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 %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x10(%rsp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %ebp       # imm = 0xFFFFD8F0
jne 0x4c0a
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movq %rdi, 0x18(%rax)
movl %esi, 0x20(%rax)
movq %rax, %rdi
callq 0x2e56
movl %eax, %ebp
testl %eax, %eax
jne 0x4c0a
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x2e5e
cmpl $0x1, %eax
jne 0x4be3
movq 0x30(%rsp), %rax
movq %rax, (%rbx)
movq 0x40(%rsp), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x4c0a
movq 0x58(%rsp), %rdi
callq *0x50(%rsp)
jmp 0x4c0a
movl %eax, %r14d
movq 0x40(%rsp), %rsi
testq %rsi, %rsi
je 0x4bf9
movq 0x58(%rsp), %rdi
callq *0x50(%rsp)
movl %r14d, %eax
xorl $-0x5, %eax
orl 0x10(%rsp), %eax
pushq $-0x3
popq %rbp
cmovnel %r14d, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 $0x2b28, %rsp           # imm = 0x2B28
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
andq $0x0, (%rdx)
leaq 0x28(%rsp), %rax
andl $0x0, (%rax)
andl $-0x7, %ebp
orl $0x4, %ebp
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x20(%rsp), %rax
subq %r15, %rax
movq %rax, 0x10(%rsp)
movq %r12, %rax
subq %r14, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
leaq (%rax,%r15), %rsi
addq %r13, %r14
testq %r13, %r13
cmoveq %r13, %r14
movl %ebp, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %r14, %r8
leaq 0x8(%rsp), %r9
callq 0x31ac
testl %eax, %eax
js 0x4d0c
cmpl $0x1, %eax
je 0x4d0c
addq 0x10(%rsp), %r15
movq (%rbx), %r14
addq 0x8(%rsp), %r14
movq %r14, (%rbx)
testl %eax, %eax
je 0x4d1b
addq %r12, %r12
cmpq $0x81, %r12
movl $0x80, %eax
cmovbq %rax, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x1100
testq %rax, %rax
je 0x4d0c
movq %rax, %r13
jmp 0x4c7c
movq %r13, %rdi
callq 0x1030
andq $0x0, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x2b28, %rsp           # imm = 0x2B28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 0x55cc
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movl %r8d, 0x4(%rsp)
movl $0x4df80, %edi          # imm = 0x4DF80
callq 0x10f0
testq %rax, %rax
je 0x55cc
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl 0x4(%rsp), %ecx
callq 0x19cc
pushq $0x4
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x550d
xorl %ebp, %ebp
cmpl $0x1, %eax
sete %bpl
movq %r12, %rdi
callq 0x1030
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/wkoszek[P]mini_gzip/miniz.c
// 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 0x5625
movl %ecx, %r8d
movq %rdx, %rbx
andq $0x0, (%rdx)
movq %rsp, %rcx
movl $0x1, 0x18(%rcx)
leaq 0x1f(%rip), %rdx        # 0x562d
callq 0x5550
testl %eax, %eax
je 0x5625
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
jmp 0x5627
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// 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 0x568f
xorl %ebp, %ebp
cmpl $0x0, 0x18(%rbx)
je 0x56a7
movl $0x80, %eax
addq %r12, %r12
cmpq $0x81, %r12
cmovbq %rax, %r12
cmpq %r12, %r13
ja 0x565e
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x1100
testq %rax, %rax
je 0x56a7
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
jmp 0x5693
movq 0x10(%rbx), %rax
addq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10e0
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/wkoszek[P]mini_gzip/miniz.c
// 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 0x56fa
movq %rsp, %rax
movq %rdi, 0x10(%rax)
movq %rsi, 0x8(%rax)
leaq -0xb2(%rip), %r9        # 0x562d
movq %rdx, %rdi
movq %rcx, %rsi
movq %r9, %rdx
movq %rax, %rcx
callq 0x5550
testl %eax, %eax
je 0x56fa
movq (%rsp), %rax
jmp 0x56fc
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_record_match
static __forceinline void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
{
  mz_uint32 s0, s1;

  MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE));

  d->m_total_lz_bytes += match_len;

  d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN);

  match_dist -= 1;
  d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF);
  d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); d->m_pLZ_code_buf += 3;

  *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); if (--d->m_num_flags_left == 0) { d->m_num_flags_left = 8; d->m_pLZ_flags = d->m_pLZ_code_buf++; }

  s0 = s_tdefl_small_dist_sym[match_dist & 511]; s1 = s_tdefl_large_dist_sym[match_dist >> 8];
  d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++;

  d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++;
}

// Assembly:
cmpl $0x3, %esi
jb 0x5a71
decl %edx
cmpl $0x8000, %edx           # imm = 0x8000
jae 0x5a71
addl %esi, 0x5c(%rdi)
addl $-0x3, %esi
movq 0x38(%rdi), %rax
movb %sil, (%rax)
movq 0x38(%rdi), %rax
movb %dl, 0x1(%rax)
movl %edx, %eax
shrl $0x8, %eax
movq 0x38(%rdi), %rcx
movb %al, 0x2(%rcx)
addq $0x3, 0x38(%rdi)
movq 0x40(%rdi), %rcx
movb (%rcx), %r8b
shrb %r8b
orb $-0x80, %r8b
movb %r8b, (%rcx)
decl 0x58(%rdi)
jne 0x5a2a
movl $0x8, 0x58(%rdi)
movq 0x38(%rdi), %rcx
leaq 0x1(%rcx), %r8
movq %r8, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movl %edx, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
leaq 0x1b27(%rip), %r8       # 0x7560
addq %rcx, %r8
leaq 0x1d1d(%rip), %rcx      # 0x7760
addq %rax, %rcx
cmpl $0x200, %edx            # imm = 0x200
cmovbq %r8, %rcx
movzbl (%rcx), %eax
incw 0x8412(%rdi,%rax,2)
movl %esi, %eax
leaq 0x1d7c(%rip), %rcx      # 0x77e0
movzwl (%rcx,%rax,2), %eax
incw 0x81d2(%rdi,%rax,2)
retq
pushq %rax
leaq 0x2632(%rip), %rdi      # 0x80ab
leaq 0x243a(%rip), %rsi      # 0x7eba
leaq 0x2682(%rip), %rcx      # 0x8109
movl $0x856, %edx            # imm = 0x856
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/KhuramAli[P]JAM-Benchmark/stack_lock-synchronized/code05.cpp
// Function: consume()
void consume()
{
	while (!stack.empty()){
		std::lock_guard < std::mutex > lock(mtx);
		if(!stack.empty()){
			sum += stack.top();
			stack.pop();
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2dec(%rip), %rbx      # 0x4140
movl $0x200, %r15d           # imm = 0x200
leaq 0x2d87(%rip), %r14      # 0x40e8
movq 0x2db0(%rip), %rax      # 0x4118
cmpq 0x2d89(%rip), %rax      # 0x40f8
je 0x13bb
movq %rbx, %rdi
callq 0x1756
movq 0x2d98(%rip), %rax      # 0x4118
cmpq 0x2d71(%rip), %rax      # 0x40f8
je 0x13b1
cmpq 0x2d90(%rip), %rax      # 0x4120
jne 0x13a0
movq 0x2d97(%rip), %rax      # 0x4130
movq -0x8(%rax), %rax
addq %r15, %rax
movl -0x4(%rax), %eax
addl %eax, 0x2d8f(%rip)      # 0x4138
movq %r14, %rdi
callq 0x1992
movq %rbx, %rdi
callq 0x1090
jmp 0x1361
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/KhuramAli[P]JAM-Benchmark/stack_lock-synchronized/code05.cpp
// Function: main
int main()
{
	std::thread t1{ produce };
	std::thread t2{ consume };
	std::thread t3{ consume };
	t1.join();
	t2.join();
	t3.join();
	consume();
	std::cout << sum << '\n';
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq -0xf1(%rip), %rsi       # 0x12dc
leaq 0x18(%rsp), %rdi
callq 0x14b4
leaq -0x96(%rip), %rsi       # 0x1348
leaq 0x10(%rsp), %rdi
callq 0x14b4
leaq -0xa7(%rip), %rsi       # 0x1348
leaq 0x8(%rsp), %rdi
callq 0x14b4
leaq 0x18(%rsp), %rdi
callq 0x1150
leaq 0x10(%rsp), %rdi
callq 0x1150
leaq 0x8(%rsp), %rdi
callq 0x1150
callq 0x1348
movl 0x2d16(%rip), %esi      # 0x4138
movq 0x2baf(%rip), %rdi      # 0x3fd8
callq 0x1160
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x10f0
leaq 0x8(%rsp), %rdi
callq 0x151a
leaq 0x10(%rsp), %rdi
callq 0x151a
leaq 0x18(%rsp), %rdi
callq 0x151a
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x1476
movq %rax, %rbx
jmp 0x1480
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x151a
leaq 0x10(%rsp), %rdi
callq 0x151a
leaq 0x18(%rsp), %rdi
callq 0x151a
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/pali[P]bmfdec/bmfparse.c
// Function: print_variable_type
static void print_variable_type(FILE *fout, struct mof_variable *variable) {
  char *variable_type = "unknown";
  char *type = NULL;
  switch (variable->variable_type) {
  case MOF_VARIABLE_BASIC:
  case MOF_VARIABLE_BASIC_ARRAY:
    variable_type = "Basic";
    switch (variable->type.basic) {
    case MOF_BASIC_TYPE_STRING: type = "String"; break;
    case MOF_BASIC_TYPE_REAL64: type = "Real64"; break;
    case MOF_BASIC_TYPE_REAL32: type = "Real32"; break;
    case MOF_BASIC_TYPE_SINT32: type = "SInt32"; break;
    case MOF_BASIC_TYPE_UINT32: type = "UInt32"; break;
    case MOF_BASIC_TYPE_SINT16: type = "SInt16"; break;
    case MOF_BASIC_TYPE_UINT16: type = "UInt16"; break;
    case MOF_BASIC_TYPE_SINT64: type = "SInt64"; break;
    case MOF_BASIC_TYPE_UINT64: type = "UInt64"; break;
    case MOF_BASIC_TYPE_SINT8: type = "SInt8"; break;
    case MOF_BASIC_TYPE_UINT8: type = "UInt8"; break;
    case MOF_BASIC_TYPE_DATETIME: type = "Datetime"; break;
    case MOF_BASIC_TYPE_CHAR16: type = "Char16"; break;
    case MOF_BASIC_TYPE_BOOLEAN: type = "Boolean"; break;
    default: type = "unknown"; break;
    }
    break;
  case MOF_VARIABLE_OBJECT:
  case MOF_VARIABLE_OBJECT_ARRAY:
    variable_type = "Object";
    type = variable->type.object;
    break;
  default:
    break;
  }
  fprintf(fout, "%s", variable_type);
  if (type)
    fprintf(fout, ":%s", type);
  if (variable->variable_type == MOF_VARIABLE_BASIC_ARRAY || variable->variable_type == MOF_VARIABLE_OBJECT_ARRAY) {
    fprintf(fout, "[");
    if (variable->has_array_max)
      fprintf(fout, "%d", variable->array_max);
    fprintf(fout, "]");
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x524f
leaq 0xefb(%rip), %rcx       # 0x6100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x20(%r14), %eax
decl %eax
cmpl $0xe, %eax
jae 0x523f
movl %eax, %eax
leaq 0x3b4e(%rip), %rcx      # 0x8d70
leaq (%rcx,%rax,8), %rax
leaq 0x186f(%rip), %rdi      # 0x6a9c
jmp 0x523a
leaq 0x20(%r14), %rax
leaq 0x1868(%rip), %rdi      # 0x6aa2
movq (%rax), %r15
jmp 0x5259
leaq 0x118b(%rip), %r15      # 0x63d1
leaq 0x184f(%rip), %rdi      # 0x6a9c
jmp 0x5259
leaq 0x117b(%rip), %rdi      # 0x63d1
xorl %r15d, %r15d
movq %rbx, %rsi
callq 0x10b0
testq %r15, %r15
je 0x527a
leaq 0x183c(%rip), %rsi      # 0x6aa9
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
movl 0x18(%r14), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x52bd
pushq $0x5b
popq %rdi
movq %rbx, %rsi
callq 0x10c0
cmpb $0x0, 0x2c(%r14)
je 0x52ad
movl 0x28(%r14), %edx
leaq 0x180a(%rip), %rsi      # 0x6aad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10f0
pushq $0x5d
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10c0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pali[P]bmfdec/bmfparse.c
// Function: print_variable
static void print_variable(FILE *fout, struct mof_variable *variable, int indent) {
  fprintf(fout, "%*.s  Name=%s\n", indent, "", variable->name);
  fprintf(fout, "%*.s  Type=", indent, "");
  print_variable_type(fout, variable);
  fprintf(fout, "\n");
  print_qualifiers(fout, variable->qualifiers, variable->qualifiers_count, indent+2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %r8
leaq 0x16ab(%rip), %rsi      # 0x6989
leaq 0x1235(%rip), %r12      # 0x651a
movq %r12, %rcx
xorl %eax, %eax
callq 0x10f0
leaq 0x179a(%rip), %rsi      # 0x6a90
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x51e9
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x10c0
movq 0x8(%r15), %rsi
movl (%r15), %edx
addl $0x2, %ebx
movq %r14, %rdi
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4ffe
// File: /workspace/github_c_makefile_star2_O2/0x0203[P]schack_poc/./nuklear.h
// Function: nk_murmur_hash
NK_API nk_hash
nk_murmur_hash(const void * key, int len, nk_hash seed)
{
    /* 32-Bit MurmurHash3: https://code.google.com/p/smhasher/wiki/MurmurHash3*/
    #define NK_ROTL(x,r) ((x) << (r) | ((x) >> (32 - r)))
    union {const nk_uint *i; const nk_byte *b;} conv = {0};
    const nk_byte *data = (const nk_byte*)key;
    const int nblocks = len/4;
    nk_uint h1 = seed;
    const nk_uint c1 = 0xcc9e2d51;
    const nk_uint c2 = 0x1b873593;
    const nk_byte *tail;
    const nk_uint *blocks;
    nk_uint k1;
    int i;

    /* body */
    if (!key) return 0;
    conv.b = (data + nblocks*4);
    blocks = (const nk_uint*)conv.i;
    for (i = -nblocks; i; ++i) {
        k1 = blocks[i];
        k1 *= c1;
        k1 = NK_ROTL(k1,15);
        k1 *= c2;

        h1 ^= k1;
        h1 = NK_ROTL(h1,13);
        h1 = h1*5+0xe6546b64;
    }

    /* tail */
    tail = (const nk_byte*)(data + nblocks*4);
    k1 = 0;
    switch (len & 3) {
    case 3: k1 ^= (nk_uint)(tail[2] << 16); /* fallthrough */
    case 2: k1 ^= (nk_uint)(tail[1] << 8u); /* fallthrough */
    case 1: k1 ^= tail[0];
            k1 *= c1;
            k1 = NK_ROTL(k1,15);
            k1 *= c2;
            h1 ^= k1;
            break;
    default: break;
    }

    /* finalization */
    h1 ^= (nk_uint)len;
    /* fmix32 */
    h1 ^= h1 >> 16;
    h1 *= 0x85ebca6b;
    h1 ^= h1 >> 13;
    h1 *= 0xc2b2ae35;
    h1 ^= h1 >> 16;

    #undef NK_ROTL
    return h1;
}

// Assembly:
testq %rdi, %rdi
je 0x3ebd
movl %edx, %ecx
pushq $0x4
popq %r8
movl %esi, %eax
cltd
idivl %r8d
leal (,%rax,4), %edx
movslq %edx, %rdx
addq %rdx, %rdi
negl %eax
cltq
testq %rax, %rax
je 0x3e54
movl (%rdi,%rax,4), %edx
imull $0xcc9e2d51, %edx, %r8d # imm = 0xCC9E2D51
imull $0x16a88000, %edx, %edx # imm = 0x16A88000
shrl $0x11, %r8d
orl %edx, %r8d
imull $0x1b873593, %r8d, %edx # imm = 0x1B873593
xorl %ecx, %edx
roll $0xd, %edx
leal (%rdx,%rdx,4), %ecx
addl $0xe6546b64, %ecx       # imm = 0xE6546B64
incq %rax
jmp 0x3e1e
movl %esi, %edx
andl $0x3, %edx
xorl %eax, %eax
leaq 0x207ce(%rip), %r8      # 0x24630
movslq (%r8,%rdx,4), %rdx
addq %r8, %rdx
jmpq *%rdx
movzbl 0x2(%rdi), %eax
shll $0x10, %eax
movzbl 0x1(%rdi), %edx
shll $0x8, %edx
orl %edx, %eax
movzbl (%rdi), %edx
xorl %eax, %edx
imull $0xcc9e2d51, %edx, %eax # imm = 0xCC9E2D51
imull $0x16a88000, %edx, %edx # imm = 0x16A88000
shrl $0x11, %eax
orl %edx, %eax
imull $0x1b873593, %eax, %eax # imm = 0x1B873593
xorl %eax, %ecx
xorl %esi, %ecx
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
imull $0x85ebca6b, %eax, %eax # imm = 0x85EBCA6B
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae35, %ecx, %ecx # imm = 0xC2B2AE35
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/0x0203[P]schack_poc/./nuklear.h
// Function: nk_input_key
NK_API void
nk_input_key(struct nk_context *ctx, enum nk_keys key, int down)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->keyboard.keys[key].down != down)
        in->keyboard.keys[key].clicked++;
    in->keyboard.keys[key].down = down;
}

// Assembly:
testq %rdi, %rdi
je 0x79e3
movl %esi, %eax
cmpl %edx, (%rdi,%rax,8)
je 0x79df
incl 0x4(%rdi,%rax,8)
movl %edx, (%rdi,%rax,8)
retq
pushq %rax
leaq 0x20cba(%rip), %rdi     # 0x286a5
leaq 0x1de21(%rip), %rsi     # 0x25813
leaq 0x1eead(%rip), %rcx     # 0x268a6
movl $0x365c, %edx           # imm = 0x365C
callq 0x3100
// File: /workspace/github_c_makefile_star2_O2/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_image_free
void
nk_xsurf_image_free(struct nk_image* image)
{
    XSurface *surf = xlib.surf;
    XImageWithAlpha *aimage = image->handle.ptr;
    if (!aimage) return;
    XDestroyImage(aimage->ximage);
    XFreePixmap(surf->dpy, aimage->clipMask);
    XFreeGC(surf->dpy, aimage->clipMaskGC);
    free(aimage);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1cc3e
movq 0x1ea01(%rip), %r14     # 0x3b610
movq (%rbx), %rdi
callq *0x60(%rdi)
movq 0x8(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x3510
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x32d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3200
addq $0x8, %rsp
popq %rbx
popq %r14
retq