LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_inflate
unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
                         const unsigned char* in, size_t insize,
                         const LodePNGDecompressSettings* settings) {
  ucvector v = ucvector_init(*out, *outsize);
  unsigned error = lodepng_inflatev(&v, in, insize, settings);
  *out = v.data;
  *outsize = v.size;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x40(%rbp), %rdi
callq 0x50f0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x5120
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: ucvector_init
static ucvector ucvector_init(unsigned char* buffer, size_t size) {
  ucvector v;
  v.data = buffer;
  v.allocsize = v.size = size;
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_inflatev
static unsigned lodepng_inflatev(ucvector* out,
                                 const unsigned char* in, size_t insize,
                                 const LodePNGDecompressSettings* settings) {
  unsigned BFINAL = 0;
  LodePNGBitReader reader;
  unsigned error = LodePNGBitReader_init(&reader, in, insize);

  if(error) return error;

  while(!BFINAL) {
    unsigned BTYPE;
    if(!ensureBits9(&reader, 3)) return 52; /*error, bit pointer will jump past memory*/
    BFINAL = readBits(&reader, 1);
    BTYPE = readBits(&reader, 2);

    if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
    else if(BTYPE == 0) error = inflateNoCompression(out, &reader, settings); /*no compression*/
    else error = inflateHuffmanBlock(out, &reader, BTYPE); /*compression, BTYPE 01 or 10*/

    if(error) return error;
  }

  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4010
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x5164
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x520f
jmp 0x5166
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5178
jmp 0x5209
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x4550
cmpl $0x0, %eax
jne 0x5194
movl $0x34, -0x4(%rbp)
jmp 0x520f
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x4650
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x2, %esi
callq 0x4650
movl %eax, -0x60(%rbp)
cmpl $0x3, -0x60(%rbp)
jne 0x51c5
movl $0x14, -0x4(%rbp)
jmp 0x520f
cmpl $0x0, -0x60(%rbp)
jne 0x51e1
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x105d0
movl %eax, -0x5c(%rbp)
jmp 0x51f4
movq -0x10(%rbp), %rdi
movl -0x60(%rbp), %edx
leaq -0x58(%rbp), %rsi
callq 0x10750
movl %eax, -0x5c(%rbp)
jmp 0x51f6
cmpl $0x0, -0x5c(%rbp)
je 0x5204
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x520f
jmp 0x5166
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: deflate
static unsigned deflate(unsigned char** out, size_t* outsize,
                        const unsigned char* in, size_t insize,
                        const LodePNGCompressSettings* settings) {
  if(settings->custom_deflate) {
    return settings->custom_deflate(out, outsize, in, insize, settings);
  } else {
    return lodepng_deflate(out, outsize, in, insize, settings);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x587a
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x5896
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x5220
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_decompress_settings_init
void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings) {
  settings->ignore_adler32 = 0;
  settings->ignore_nlen = 0;

  settings->custom_zlib = 0;
  settings->custom_inflate = 0;
  settings->custom_context = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_crc32
unsigned lodepng_crc32(const unsigned char* data, size_t length) {
  unsigned r = 0xffffffffu;
  size_t i;
  for(i = 0; i < length; ++i) {
    r = lodepng_crc32_table[(r ^ data[i]) & 0xffu] ^ (r >> 8u);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5a52
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1c6da(%rip), %rax     # 0x22110
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5a0b
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_strlen
static size_t lodepng_strlen(const char* a) {
  const char* orig = a;
  /* avoid warning about unused function in case of disabled COMPILE... macros */
  (void)(&lodepng_strlen);
  while(*a) a++;
  return (size_t)(a - orig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5bd7
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5bc0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_next
unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5d7b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x5d88
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5e51
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0x5dff
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x5e51
movq -0x10(%rbp), %rdi
callq 0x5a60
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x20(%rbp), %rdx
callq 0x5e60
cmpl $0x0, %eax
je 0x5e29
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5e51
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5e49
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5e51
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_next_const
const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    const unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5ecb
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x5ed8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5fa1
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0x5f4f
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x5fa1
movq -0x10(%rbp), %rdi
callq 0x5a60
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x20(%rbp), %rdx
callq 0x5e60
cmpl $0x0, %eax
je 0x5f79
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5fa1
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5f99
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5fa1
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_find
unsigned char* lodepng_chunk_find(unsigned char* chunk, unsigned char* end, const char type[5]) {
  for(;;) {
    if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */
    if(lodepng_chunk_type_equals(chunk, type)) return chunk;
    chunk = lodepng_chunk_next(chunk, end);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5fdf
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x5fe9
movq $0x0, -0x8(%rbp)
jmp 0x6017
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5b10
cmpb $0x0, %al
je 0x6004
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6017
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d50
movq %rax, -0x10(%rbp)
jmp 0x5fc4
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_find_const
const unsigned char* lodepng_chunk_find_const(const unsigned char* chunk, const unsigned char* end, const char type[5]) {
  for(;;) {
    if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */
    if(lodepng_chunk_type_equals(chunk, type)) return chunk;
    chunk = lodepng_chunk_next_const(chunk, end);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x605f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x6069
movq $0x0, -0x8(%rbp)
jmp 0x6097
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5b10
cmpb $0x0, %al
je 0x6084
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6097
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5ea0
movq %rax, -0x10(%rbp)
jmp 0x6044
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_append
unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk) {
  unsigned i;
  size_t total_chunk_length, new_length;
  unsigned char *chunk_start, *new_buffer;

  if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return 77;
  if(lodepng_addofl(*outsize, total_chunk_length, &new_length)) return 77;

  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outsize) = new_length;
  chunk_start = &(*out)[new_length - total_chunk_length];

  for(i = 0; i != total_chunk_length; ++i) chunk_start[i] = chunk[i];

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5a60
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x30(%rbp), %rdx
callq 0x5e60
cmpl $0x0, %eax
je 0x60f0
movl $0x4d, -0x4(%rbp)
jmp 0x619b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5e60
cmpl $0x0, %eax
je 0x6115
movl $0x4d, -0x4(%rbp)
jmp 0x619b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x61b0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6139
movl $0x53, -0x4(%rbp)
jmp 0x619b
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x30(%rbp), %rax
je 0x6194
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x40(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x616c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_create
unsigned lodepng_chunk_create(unsigned char** out, size_t* outsize,
                              unsigned length, const char* type, const unsigned char* data) {
  ucvector v = ucvector_init(*out, *outsize);
  unsigned error = lodepng_chunk_createv(&v, length, type, data);
  *out = v.data;
  *outsize = v.size;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x40(%rbp), %rdi
callq 0x50f0
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x6250
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_createv
static unsigned lodepng_chunk_createv(ucvector* out,
                                      unsigned length, const char* type, const unsigned char* data) {
  unsigned char* chunk;
  CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, length, type));

  /*3: the data*/
  lodepng_memcpy(chunk + 8, data, length);

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x14120
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x628c
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x62b2
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x6440
movq -0x30(%rbp), %rdi
callq 0x5d00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_color_mode_copy
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source) {
  lodepng_color_mode_cleanup(dest);
  lodepng_memcpy(dest, source, sizeof(LodePNGColorMode));
  if(source->palette) {
    dest->palette = (unsigned char*)lodepng_malloc(1024);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    lodepng_memcpy(dest->palette, source->palette, source->palettesize * 4);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6330
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x28, %edx
callq 0x6440
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x642b
movl $0x400, %edi            # imm = 0x400
callq 0x3de0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x640a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x640a
movl $0x53, -0x4(%rbp)
jmp 0x6432
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x2, %rdx
callq 0x6440
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_color_mode_make
LodePNGColorMode lodepng_color_mode_make(LodePNGColorType colortype, unsigned bitdepth) {
  LodePNGColorMode result;
  lodepng_color_mode_init(&result);
  result.colortype = colortype;
  result.bitdepth = bitdepth;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
callq 0x62c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x4(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_palette_add
unsigned lodepng_palette_add(LodePNGColorMode* info,
                             unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
  if(!info->palette) /*allocate palette if empty*/ {
    lodepng_color_mode_alloc_palette(info);
    if(!info->palette) return 83; /*alloc fail*/
  }
  if(info->palettesize >= 256) {
    return 108; /*too many palette values*/
  }
  info->palette[4 * info->palettesize + 0] = r;
  info->palette[4 * info->palettesize + 1] = g;
  info->palette[4 * info->palettesize + 2] = b;
  info->palette[4 * info->palettesize + 3] = a;
  ++info->palettesize;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movb %dl, -0x12(%rbp)
movb %cl, -0x13(%rbp)
movb %al, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6519
movq -0x10(%rbp), %rdi
callq 0x65c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6517
movl $0x53, -0x4(%rbp)
jmp 0x65b5
jmp 0x6519
movq -0x10(%rbp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jb 0x6533
movl $0x6c, -0x4(%rbp)
jmp 0x65b5
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, (%rax,%rcx)
movb -0x12(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x1(%rax,%rcx)
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x2(%rax,%rcx)
movb -0x14(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x3(%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_color_mode_alloc_palette
static void lodepng_color_mode_alloc_palette(LodePNGColorMode* info) {
  size_t i;
  /*if the palette is already allocated, it will have size 1024 so no reallocation needed in that case*/
  /*the palette must have room for up to 256 colors with 4 bytes each.*/
  if(!info->palette) info->palette = (unsigned char*)lodepng_malloc(1024);
  if(!info->palette) return; /*alloc fail*/
  for(i = 0; i != 256; ++i) {
    /*Initialize all unused colors with black, the value used for invalid palette indices.
    This is an error according to the PNG spec, but common PNG decoders make it black instead.
    That makes color conversion slightly faster due to no error handling needed.*/
    info->palette[i * 4 + 0] = 0;
    info->palette[i * 4 + 1] = 0;
    info->palette[i * 4 + 2] = 0;
    info->palette[i * 4 + 3] = 255;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x65ec
movl $0x400, %edi            # imm = 0x400
callq 0x3de0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x65f9
jmp 0x666c
movq $0x0, -0x10(%rbp)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
je 0x666c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
movb $0x0, 0x2(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
movb $-0x1, 0x3(%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6601
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: getNumColorChannels
static unsigned getNumColorChannels(LodePNGColorType colortype) {
  switch(colortype) {
    case LCT_GREY: return 1;
    case LCT_RGB: return 3;
    case LCT_PALETTE: return 1;
    case LCT_GREY_ALPHA: return 2;
    case LCT_RGBA: return 4;
    case LCT_MAX_OCTET_VALUE: return 0; /* invalid color type */
    default: return 0; /*invalid color type*/
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x6737
jmp 0x6703
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x6740
jmp 0x670d
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x6749
jmp 0x6717
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x6752
jmp 0x6721
movl -0xc(%rbp), %eax
subl $0x6, %eax
je 0x675b
jmp 0x672b
movl -0xc(%rbp), %eax
subl $0xff, %eax
je 0x6764
jmp 0x676d
movl $0x1, -0x4(%rbp)
jmp 0x6774
movl $0x3, -0x4(%rbp)
jmp 0x6774
movl $0x1, -0x4(%rbp)
jmp 0x6774
movl $0x2, -0x4(%rbp)
jmp 0x6774
movl $0x4, -0x4(%rbp)
jmp 0x6774
movl $0x0, -0x4(%rbp)
jmp 0x6774
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_add_text_sized
static unsigned lodepng_add_text_sized(LodePNGInfo* info, const char* key, const char* str, size_t size) {
  char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));

  if(new_keys) info->text_keys = new_keys;
  if(new_strings) info->text_strings = new_strings;

  if(!new_keys || !new_strings) return 83; /*alloc fail*/

  ++info->text_num;
  info->text_keys[info->text_num - 1] = alloc_string(key);
  info->text_strings[info->text_num - 1] = alloc_string_sized(str, size);
  if(!info->text_keys[info->text_num - 1] || !info->text_strings[info->text_num - 1]) return 83; /*alloc fail*/

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x61b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x61b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x69ed
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
cmpq $0x0, -0x38(%rbp)
je 0x6a00
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x6a0e
cmpq $0x0, -0x38(%rbp)
jne 0x6a1a
movl $0x53, -0x4(%rbp)
jmp 0x6abc
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rdi
callq 0x14200
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14230
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6aac
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6ab5
movl $0x53, -0x4(%rbp)
jmp 0x6abc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_clear_icc
void lodepng_clear_icc(LodePNGInfo* info) {
  string_cleanup(&info->iccp_name);
  lodepng_free(info->iccp_profile);
  info->iccp_profile = NULL;
  info->iccp_profile_size = 0;
  info->iccp_defined = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x7030
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rdi
callq 0x5060
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x100(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xe8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_assign_icc
static unsigned lodepng_assign_icc(LodePNGInfo* info, const char* name, const unsigned char* profile, unsigned profile_size) {
  if(profile_size == 0) return 100; /*invalid ICC profile size*/

  info->iccp_name = alloc_string(name);
  info->iccp_profile = (unsigned char*)lodepng_malloc(profile_size);

  if(!info->iccp_name || !info->iccp_profile) return 83; /*alloc fail*/

  lodepng_memcpy(info->iccp_profile, profile, profile_size);
  info->iccp_profile_size = profile_size;

  return 0; /*ok*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x6f99
movl $0x64, -0x4(%rbp)
jmp 0x701a
movq -0x18(%rbp), %rdi
callq 0x14200
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xf0(%rax)
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x3de0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x6fe4
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x6fed
movl $0x53, -0x4(%rbp)
jmp 0x701a
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x6440
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x100(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_info_init
void lodepng_info_init(LodePNGInfo* info) {
  lodepng_color_mode_init(&info->color);
  info->interlace_method = 0;
  info->compression_method = 0;
  info->filter_method = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  info->background_defined = 0;
  info->background_r = info->background_g = info->background_b = 0;

  LodePNGText_init(info);
  LodePNGIText_init(info);

  info->time_defined = 0;
  info->phys_defined = 0;

  info->gama_defined = 0;
  info->chrm_defined = 0;
  info->srgb_defined = 0;
  info->iccp_defined = 0;
  info->iccp_name = NULL;
  info->iccp_profile = NULL;

  LodePNGUnknownChunks_init(info);
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x62c0
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rdi
callq 0x7160
movq -0x8(%rbp), %rdi
callq 0x7190
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xb4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xe8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rdi
callq 0x71e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_info_copy
unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source) {
  lodepng_info_cleanup(dest);
  lodepng_memcpy(dest, source, sizeof(LodePNGInfo));
  lodepng_color_mode_init(&dest->color);
  CERROR_TRY_RETURN(lodepng_color_mode_copy(&dest->color, &source->color));

#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  CERROR_TRY_RETURN(LodePNGText_copy(dest, source));
  CERROR_TRY_RETURN(LodePNGIText_copy(dest, source));
  if(source->iccp_defined) {
    CERROR_TRY_RETURN(lodepng_assign_icc(dest, source->iccp_name, source->iccp_profile, source->iccp_profile_size));
  }

  LodePNGUnknownChunks_init(dest);
  CERROR_TRY_RETURN(LodePNGUnknownChunks_copy(dest, source));
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7240
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x138, %edx            # imm = 0x138
callq 0x6440
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x62c0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x63a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7331
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x73e7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x73f0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x7352
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x73e7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x74a0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x7370
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x73e7
movq -0x18(%rbp), %rax
cmpl $0x0, 0xe8(%rax)
je 0x73b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0xf8(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x100(%rax), %ecx
callq 0x6f70
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x73b7
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x73e7
jmp 0x73b9
movq -0x10(%rbp), %rdi
callq 0x71e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7590
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x73e0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x73e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_color_mode_equal
static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b) {
  size_t i;
  if(a->colortype != b->colortype) return 0;
  if(a->bitdepth != b->bitdepth) return 0;
  if(a->key_defined != b->key_defined) return 0;
  if(a->key_defined) {
    if(a->key_r != b->key_r) return 0;
    if(a->key_g != b->key_g) return 0;
    if(a->key_b != b->key_b) return 0;
  }
  if(a->palettesize != b->palettesize) return 0;
  for(i = 0; i != a->palettesize * 4; ++i) {
    if(a->palette[i] != b->palette[i]) return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x7b56
movl $0x0, -0x4(%rbp)
jmp 0x7c67
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x7b72
movl $0x0, -0x4(%rbp)
jmp 0x7c67
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x7b8e
movl $0x0, -0x4(%rbp)
jmp 0x7c67
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x7beb
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
je 0x7bb4
movl $0x0, -0x4(%rbp)
jmp 0x7c67
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0x7bd0
movl $0x0, -0x4(%rbp)
jmp 0x7c67
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x24(%rcx), %eax
je 0x7be9
movl $0x0, -0x4(%rbp)
jmp 0x7c67
jmp 0x7beb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x7c06
movl $0x0, -0x4(%rbp)
jmp 0x7c67
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
je 0x7c60
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x7c50
movl $0x0, -0x4(%rbp)
jmp 0x7c67
jmp 0x7c52
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7c0e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: color_tree_add
static unsigned color_tree_add(ColorTree* tree,
                               unsigned char r, unsigned char g, unsigned char b, unsigned char a, unsigned index) {
  int bit;
  for(bit = 0; bit < 8; ++bit) {
    int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1);
    if(!tree->children[i]) {
      tree->children[i] = (ColorTree*)lodepng_malloc(sizeof(ColorTree));
      if(!tree->children[i]) return 83; /*alloc fail*/
      color_tree_init(tree->children[i]);
    }
    tree = tree->children[i];
  }
  tree->index = (int)index;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movb %dl, -0x12(%rbp)
movb %cl, -0x13(%rbp)
movb %al, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x7d8a
movzbl -0x11(%rbp), %eax
movl -0x1c(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
shll $0x3, %eax
movzbl -0x12(%rbp), %edx
movl -0x1c(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x2, %ecx
addl %ecx, %eax
movzbl -0x13(%rbp), %edx
movl -0x1c(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll %ecx
addl %ecx, %eax
movzbl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7d6c
movl $0x88, %edi
callq 0x3de0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7d5b
movl $0x53, -0x4(%rbp)
jmp 0x7d9e
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7c70
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7cc7
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x80(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_color_stats_init
void lodepng_color_stats_init(LodePNGColorStats* stats) {
  /*stats*/
  stats->colored = 0;
  stats->key = 0;
  stats->key_r = stats->key_g = stats->key_b = 0;
  stats->alpha = 0;
  stats->numcolors = 0;
  stats->bits = 1;
  stats->numpixels = 0;
  /*settings*/
  stats->allow_palette = 1;
  stats->allow_greyscale = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xa(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x418(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x420(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x428(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x42c(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: getValueRequiredBits
static unsigned getValueRequiredBits(unsigned char value) {
  if(value == 0 || value == 255) return 1;
  /*The scaling of 2-bit and 4-bit values uses multiples of 85 and 17*/
  if(value % 17 == 0) return value % 85 == 0 ? 2 : 4;
  return 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x0, %eax
je 0xa9de
movzbl -0x5(%rbp), %eax
cmpl $0xff, %eax
jne 0xa9e7
movl $0x1, -0x4(%rbp)
jmp 0xaa20
movzbl -0x5(%rbp), %eax
movl $0x11, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xaa19
movzbl -0x5(%rbp), %eax
movl $0x55, %ecx
cltd
idivl %ecx
movl $0x4, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xaa20
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: checkColorValidity
static unsigned checkColorValidity(LodePNGColorType colortype, unsigned bd) {
  switch(colortype) {
    case LCT_GREY:       if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) return 37; break;
    case LCT_RGB:        if(!(                                 bd == 8 || bd == 16)) return 37; break;
    case LCT_PALETTE:    if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8            )) return 37; break;
    case LCT_GREY_ALPHA: if(!(                                 bd == 8 || bd == 16)) return 37; break;
    case LCT_RGBA:       if(!(                                 bd == 8 || bd == 16)) return 37; break;
    case LCT_MAX_OCTET_VALUE: return 31; /* invalid color type */
    default: return 31; /* invalid color type */
  }
  return 0; /*allowed color type / bits combination*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0xadf9
jmp 0xadb6
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xae25
jmp 0xadc0
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0xae3c
jmp 0xadca
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0xae5f
jmp 0xadd8
movl -0x10(%rbp), %eax
subl $0x6, %eax
je 0xae76
jmp 0xade6
movl -0x10(%rbp), %eax
subl $0xff, %eax
je 0xae8d
jmp 0xae96
cmpl $0x1, -0xc(%rbp)
je 0xae23
cmpl $0x2, -0xc(%rbp)
je 0xae23
cmpl $0x4, -0xc(%rbp)
je 0xae23
cmpl $0x8, -0xc(%rbp)
je 0xae23
cmpl $0x10, -0xc(%rbp)
je 0xae23
movl $0x25, -0x4(%rbp)
jmp 0xaea6
jmp 0xae9f
cmpl $0x8, -0xc(%rbp)
je 0xae3a
cmpl $0x10, -0xc(%rbp)
je 0xae3a
movl $0x25, -0x4(%rbp)
jmp 0xaea6
jmp 0xae9f
cmpl $0x1, -0xc(%rbp)
je 0xae5d
cmpl $0x2, -0xc(%rbp)
je 0xae5d
cmpl $0x4, -0xc(%rbp)
je 0xae5d
cmpl $0x8, -0xc(%rbp)
je 0xae5d
movl $0x25, -0x4(%rbp)
jmp 0xaea6
jmp 0xae9f
cmpl $0x8, -0xc(%rbp)
je 0xae74
cmpl $0x10, -0xc(%rbp)
je 0xae74
movl $0x25, -0x4(%rbp)
jmp 0xaea6
jmp 0xae9f
cmpl $0x8, -0xc(%rbp)
je 0xae8b
cmpl $0x10, -0xc(%rbp)
je 0xae8b
movl $0x25, -0x4(%rbp)
jmp 0xaea6
jmp 0xae9f
movl $0x1f, -0x4(%rbp)
jmp 0xaea6
movl $0x1f, -0x4(%rbp)
jmp 0xaea6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: readChunk_PLTE
static unsigned readChunk_PLTE(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength) {
  unsigned pos = 0, i;
  color->palettesize = chunkLength / 3u;
  if(color->palettesize == 0 || color->palettesize > 256) return 38; /*error: palette too small or big*/
  lodepng_color_mode_alloc_palette(color);
  if(!color->palette && color->palettesize) {
    color->palettesize = 0;
    return 83; /*alloc fail*/
  }

  for(i = 0; i != color->palettesize; ++i) {
    color->palette[4 * i + 0] = data[pos++]; /*R*/
    color->palette[4 * i + 1] = data[pos++]; /*G*/
    color->palette[4 * i + 2] = data[pos++]; /*B*/
    color->palette[4 * i + 3] = 255; /*alpha*/
  }

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb28d
movq -0x10(%rbp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jbe 0xb299
movl $0x26, -0x4(%rbp)
jmp 0xb392
movq -0x10(%rbp), %rdi
callq 0x65c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb2d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb2d0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x53, -0x4(%rbp)
jmp 0xb392
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xb38b
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x28(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb2d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: readChunk_gAMA
static unsigned readChunk_gAMA(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) {
  if(chunkLength != 4) return 96; /*invalid gAMA chunk size*/

  info->gama_defined = 1;
  info->gama_gamma = 16777216u * data[0] + 65536u * data[1] + 256u * data[2] + data[3];

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
je 0xbec0
movl $0x60, -0x4(%rbp)
jmp 0xbf0d
movq -0x10(%rbp), %rax
movl $0x1, 0xb4(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: readChunk_sRGB
static unsigned readChunk_sRGB(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) {
  if(chunkLength != 1) return 98; /*invalid sRGB chunk size (this one is never ignored)*/

  info->srgb_defined = 1;
  info->srgb_intent = data[0];

  return 0; /* OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
je 0xc150
movl $0x62, -0x4(%rbp)
jmp 0xc176
movq -0x10(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_decode_file
unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename,
                             LodePNGColorType colortype, unsigned bitdepth) {
  unsigned char* buffer = 0;
  size_t buffersize;
  unsigned error;
  /* safe output values in case error happens */
  *out = 0;
  *w = *h = 0;
  error = lodepng_load_file(&buffer, &buffersize, filename);
  if(!error) error = lodepng_decode_memory(out, w, h, buffer, buffersize, colortype, bitdepth);
  lodepng_free(buffer);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3cb0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0xd2c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x24(%rbp), %r9d
movl -0x28(%rbp), %eax
movl %eax, (%rsp)
callq 0xd080
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5060
movl -0x3c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)