LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_find_const(unsigned char const*, unsigned char const*, char 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x13f482
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
cmpq $0xc, %rax
jge 0x13f48d
movq $0x0, 0x20(%rsp)
jmp 0x13f4c2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x13eee0
cmpb $0x0, %al
je 0x13f4ac
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13f4c2
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x13f2a0
movq %rax, 0x18(%rsp)
jmp 0x13f463
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_append(unsigned char**, unsigned long*, unsigned char const*)
unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, 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(*outlength, 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;
  (*outlength) = 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13ee80
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq 0x18(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x13f512
movl $0x4d, 0x44(%rsp)
jmp 0x13f5d5
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x13f53b
movl $0x4d, 0x44(%rsp)
jmp 0x13f5d5
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x13f5e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x13f562
movl $0x53, 0x44(%rsp)
jmp 0x13f5d5
movq (%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
subq 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpq 0x18(%rsp), %rax
je 0x13f5cd
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x8(%rsp), %rax
movl 0x24(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x13f59d
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_create(unsigned char**, unsigned long*, unsigned int, char const*, unsigned char const*)
unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
                              const char* type, const unsigned char* data) {
  unsigned i;
  unsigned char *chunk, *new_buffer;
  size_t new_length = *outlength;
  if(lodepng_addofl(new_length, length, &new_length)) return 77;
  if(lodepng_addofl(new_length, 12, &new_length)) return 77;
  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk = &(*out)[(*outlength) - length - 12];

  /*1: length*/
  lodepng_set32bitInt(chunk, (unsigned)length);

  /*2: chunk name (4 letters)*/
  chunk[4] = (unsigned char)type[0];
  chunk[5] = (unsigned char)type[1];
  chunk[6] = (unsigned char)type[2];
  chunk[7] = (unsigned char)type[3];

  /*3: the data*/
  for(i = 0; i != length; ++i) chunk[8 + i] = data[i];

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
leaq 0x8(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x13f660
movl $0x4d, 0x54(%rsp)
jmp 0x13f78a
movq 0x8(%rsp), %rdi
movl $0xc, %esi
leaq 0x8(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x13f686
movl $0x4d, 0x54(%rsp)
jmp 0x13f78a
movq 0x48(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x13f5e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x13f6b2
movl $0x53, 0x54(%rsp)
jmp 0x13f78a
movq 0x10(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movl 0x3c(%rsp), %edx
subq %rdx, %rcx
subq $0xc, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x13ecd0
movq 0x30(%rsp), %rax
movb (%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x30(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x5(%rax)
movq 0x30(%rsp), %rax
movb 0x2(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x6(%rax)
movq 0x30(%rsp), %rax
movb 0x3(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x7(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
je 0x13f778
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
addl $0x8, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x13f744
movq 0x18(%rsp), %rdi
callq 0x13f0d0
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_color_mode_alloc_palette(LodePNGColorMode*)
void lodepng_color_mode_alloc_palette(LodePNGColorMode* info) {
  size_t i;
  /*room for 256 colors with 4 bytes each. Using realloc to avoid leak if it is being overwritten*/
  info->palette = (unsigned char*)lodepng_realloc(info->palette, 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x13f5e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x13f846
jmp 0x13f8c5
movq $0x0, 0x8(%rsp)
cmpq $0x100, 0x8(%rsp)       # imm = 0x100
je 0x13f8c5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x2, %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x2, %rcx
movb $0x0, 0x1(%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x2, %rcx
movb $0x0, 0x2(%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x2, %rcx
movb $-0x1, 0x3(%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x13f84f
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_color_mode_make(LodePNGColorType, unsigned int)
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:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
callq 0x13f7a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, (%rdi)
movl 0x10(%rsp), %ecx
movl %ecx, 0x4(%rdi)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_palette_add(LodePNGColorMode*, unsigned char, unsigned char, unsigned char, unsigned char)
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:
subq $0x18, %rsp
movb %r8b, %al
movq %rdi, 0x8(%rsp)
movb %sil, 0x7(%rsp)
movb %dl, 0x6(%rsp)
movb %cl, 0x5(%rsp)
movb %al, 0x4(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x13fa8e
movq 0x8(%rsp), %rdi
callq 0x13f810
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x13fa8c
movl $0x53, 0x14(%rsp)
jmp 0x13fb3a
jmp 0x13fa8e
movq 0x8(%rsp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jb 0x13faaa
movl $0x6c, 0x14(%rsp)
jmp 0x13fb3a
movb 0x7(%rsp), %dl
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, (%rax,%rcx)
movb 0x6(%rsp), %dl
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x1(%rax,%rcx)
movb 0x5(%rsp), %dl
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x2(%rax,%rcx)
movb 0x4(%rsp), %dl
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x3(%rax,%rcx)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: getNumColorChannels(LodePNGColorType)
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;
    default: return 0; /*invalid color type*/
  }
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movq %rax, -0x10(%rsp)
subq $0x6, %rax
ja 0x13fc0a
movq -0x10(%rsp), %rax
leaq 0x365b1(%rip), %rcx     # 0x176180
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0x13fc12
movl $0x3, -0x4(%rsp)
jmp 0x13fc12
movl $0x1, -0x4(%rsp)
jmp 0x13fc12
movl $0x2, -0x4(%rsp)
jmp 0x13fc12
movl $0x4, -0x4(%rsp)
jmp 0x13fc12
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_add_text(LodePNGInfo*, char const*, char const*)
unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str) {
  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 || !new_strings) {
    lodepng_free(new_keys);
    lodepng_free(new_strings);
    return 83; /*alloc fail*/
  }

  ++info->text_num;
  info->text_keys = new_keys;
  info->text_strings = new_strings;

  info->text_keys[info->text_num - 1] = alloc_string(key);
  info->text_strings[info->text_num - 1] = alloc_string(str);

  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x13f5e0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x13f5e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x13ff1b
cmpq $0x0, 0x8(%rsp)
jne 0x13ff3c
movq 0x10(%rsp), %rdi
callq 0x13e2d0
movq 0x8(%rsp), %rdi
callq 0x13e2d0
movl $0x53, 0x34(%rsp)
jmp 0x13ffbf
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x20(%rsp), %rdi
callq 0x13ffd0
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rdi
callq 0x13ffd0
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: alloc_string(char const*)
static char* alloc_string(const char* in) {
  size_t insize = lodepng_strlen(in);
  char* out = (char*)lodepng_malloc(insize + 1);
  if(out) {
    size_t i;
    for(i = 0; i != insize; ++i) {
      out[i] = in[i];
    }
    out[i] = 0;
  }
  return out;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x13ef90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
callq 0x13ce80
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x140050
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x140042
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x14000c
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_clear_icc(LodePNGInfo*)
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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0xf0, %rdi
callq 0x1404f0
movq (%rsp), %rax
movq 0xf8(%rax), %rdi
callq 0x13e2d0
movq (%rsp), %rax
movq $0x0, 0xf8(%rax)
movq (%rsp), %rax
movl $0x0, 0x100(%rax)
movq (%rsp), %rax
movl $0x0, 0xe8(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_assign_icc(LodePNGInfo*, char const*, unsigned char const*, unsigned int)
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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x14044b
movl $0x64, 0x24(%rsp)
jmp 0x1404d9
movq 0x10(%rsp), %rdi
callq 0x13ffd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0xf0(%rax)
movl 0x4(%rsp), %eax
movl %eax, %edi
callq 0x13ce80
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0xf8(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x14049c
movq 0x18(%rsp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x1404a6
movl $0x53, 0x24(%rsp)
jmp 0x1404d9
movq 0x18(%rsp), %rax
movq 0xf8(%rax), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %eax
movl %eax, %edx
callq 0x14b830
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x100(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_info_init(LodePNGInfo*)
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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x13f7a0
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movl $0x0, 0x38(%rax)
movq (%rsp), %rax
movl $0x0, 0x44(%rax)
movq (%rsp), %rax
movl $0x0, 0x40(%rax)
movq (%rsp), %rax
movl $0x0, 0x3c(%rax)
movq (%rsp), %rdi
callq 0x140600
movq (%rsp), %rdi
callq 0x140630
movq (%rsp), %rax
movl $0x0, 0x88(%rax)
movq (%rsp), %rax
movl $0x0, 0xa4(%rax)
movq (%rsp), %rax
movl $0x0, 0xb4(%rax)
movq (%rsp), %rax
movl $0x0, 0xbc(%rax)
movq (%rsp), %rax
movl $0x0, 0xe0(%rax)
movq (%rsp), %rax
movl $0x0, 0xe8(%rax)
movq (%rsp), %rax
movq $0x0, 0xf0(%rax)
movq (%rsp), %rax
movq $0x0, 0xf8(%rax)
movq (%rsp), %rdi
callq 0x140680
popq %rax
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_info_cleanup(LodePNGInfo*)
void lodepng_info_cleanup(LodePNGInfo* info) {
  lodepng_color_mode_cleanup(&info->color);
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  LodePNGText_cleanup(info);
  LodePNGIText_cleanup(info);

  lodepng_clear_icc(info);

  LodePNGUnknownChunks_cleanup(info);
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x13f8d0
movq (%rsp), %rdi
callq 0x13fe20
movq (%rsp), %rdi
callq 0x140070
movq (%rsp), %rdi
callq 0x1403c0
movq (%rsp), %rdi
callq 0x140730
popq %rax
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_info_copy(LodePNGInfo*, LodePNGInfo const*)
unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source) {
  lodepng_info_cleanup(dest);
  *dest = *source;
  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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1406f0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
movl $0x138, %edx            # imm = 0x138
callq 0xd04d0
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
callq 0x13f7a0
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
callq 0x13f920
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x1407d9
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1408af
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1408c0
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x140800
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1408af
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x140980
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x140827
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1408af
movq 0x20(%rsp), %rax
cmpl $0x0, 0xe8(%rax)
je 0x140879
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0xf0(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0xf8(%rax), %rdx
movq 0x20(%rsp), %rax
movl 0x100(%rax), %ecx
callq 0x140420
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x140877
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1408af
jmp 0x140879
movq 0x28(%rsp), %rdi
callq 0x140680
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x140a90
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1408a7
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1408af
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_color_stats_init(LodePNGColorStats*)
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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0xc(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0xa(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x418(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x420(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x428(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x42c(%rax)
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: getValueRequiredBits(unsigned char)
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:
movb %dil, %al
movb %al, -0x5(%rsp)
movzbl -0x5(%rsp), %eax
cmpl $0x0, %eax
je 0x14444d
movzbl -0x5(%rsp), %eax
cmpl $0xff, %eax
jne 0x144457
movl $0x1, -0x4(%rsp)
jmp 0x144494
movzbl -0x5(%rsp), %eax
movl $0x11, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x14448c
movzbl -0x5(%rsp), %eax
movl $0x55, %ecx
cltd
idivl %ecx
movl $0x4, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rsp)
jmp 0x144494
movl $0x8, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: checkColorValidity(LodePNGColorType, unsigned int)
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;
    default: return 31; /* invalid color type */
  }
  return 0; /*allowed color type / bits combination*/
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0x8(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x6, %rax
ja 0x14494b
movq -0x18(%rsp), %rax
leaq 0x31905(%rip), %rcx     # 0x17619c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, -0xc(%rsp)
je 0x1448d0
cmpl $0x2, -0xc(%rsp)
je 0x1448d0
cmpl $0x4, -0xc(%rsp)
je 0x1448d0
cmpl $0x8, -0xc(%rsp)
je 0x1448d0
cmpl $0x10, -0xc(%rsp)
je 0x1448d0
movl $0x25, -0x4(%rsp)
jmp 0x14495d
jmp 0x144955
cmpl $0x8, -0xc(%rsp)
je 0x1448ed
cmpl $0x10, -0xc(%rsp)
je 0x1448ed
movl $0x25, -0x4(%rsp)
jmp 0x14495d
jmp 0x144955
cmpl $0x1, -0xc(%rsp)
je 0x144915
cmpl $0x2, -0xc(%rsp)
je 0x144915
cmpl $0x4, -0xc(%rsp)
je 0x144915
cmpl $0x8, -0xc(%rsp)
je 0x144915
movl $0x25, -0x4(%rsp)
jmp 0x14495d
jmp 0x144955
cmpl $0x8, -0xc(%rsp)
je 0x14492f
cmpl $0x10, -0xc(%rsp)
je 0x14492f
movl $0x25, -0x4(%rsp)
jmp 0x14495d
jmp 0x144955
cmpl $0x8, -0xc(%rsp)
je 0x144949
cmpl $0x10, -0xc(%rsp)
je 0x144949
movl $0x25, -0x4(%rsp)
jmp 0x14495d
jmp 0x144955
movl $0x1f, -0x4(%rsp)
jmp 0x14495d
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: readChunk_PLTE(LodePNGColorMode*, unsigned char const*, unsigned long)
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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x144d91
movq 0x18(%rsp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jbe 0x144d9e
movl $0x26, 0x24(%rsp)
jmp 0x144eab
movq 0x18(%rsp), %rdi
callq 0x13f810
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x144dda
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x144dda
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movl $0x53, 0x24(%rsp)
jmp 0x144eab
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x144ea3
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x144de1
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: readChunk_gAMA(LodePNGInfo*, unsigned char const*, unsigned long)
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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x4, -0x20(%rsp)
je 0x145c61
movl $0x60, -0x4(%rsp)
jmp 0x145cb5
movq -0x10(%rsp), %rax
movl $0x1, 0xb4(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rsp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xb8(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: readChunk_sRGB(LodePNGInfo*, unsigned char const*, unsigned long)
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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x1, -0x20(%rsp)
je 0x145f11
movl $0x62, -0x4(%rsp)
jmp 0x145f3b
movq -0x10(%rsp), %rax
movl $0x1, 0xe0(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xe4(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_decode_memory(unsigned char**, unsigned int*, unsigned int*, unsigned char const*, unsigned long, LodePNGColorType, unsigned int)
unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in,
                               size_t insize, LodePNGColorType colortype, unsigned bitdepth) {
  unsigned error;
  LodePNGState state;
  lodepng_state_init(&state);
  state.info_raw.colortype = colortype;
  state.info_raw.bitdepth = bitdepth;
  error = lodepng_decode(out, w, h, &state, in, insize);
  lodepng_state_cleanup(&state);
  return error;
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movl 0x230(%rsp), %eax
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq %rdx, 0x210(%rsp)
movq %rcx, 0x208(%rsp)
movq %r8, 0x200(%rsp)
movl %r9d, 0x1fc(%rsp)
movq %rsp, %rdi
callq 0x147240
movl 0x1fc(%rsp), %eax
movl %eax, 0x90(%rsp)
movl 0x230(%rsp), %eax
movl %eax, 0x94(%rsp)
movq 0x220(%rsp), %rdi
movq 0x218(%rsp), %rsi
movq 0x210(%rsp), %rdx
movq 0x208(%rsp), %r8
movq 0x200(%rsp), %r9
movq %rsp, %rcx
callq 0x1461c0
movl %eax, 0x1f8(%rsp)
movq %rsp, %rdi
callq 0x147290
movl 0x1f8(%rsp), %eax
addq $0x228, %rsp            # imm = 0x228
retq
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_state_init(LodePNGState*)
void lodepng_state_init(LodePNGState* state) {
#ifdef LODEPNG_COMPILE_DECODER
  lodepng_decoder_settings_init(&state->decoder);
#endif /*LODEPNG_COMPILE_DECODER*/
#ifdef LODEPNG_COMPILE_ENCODER
  lodepng_encoder_settings_init(&state->encoder);
#endif /*LODEPNG_COMPILE_ENCODER*/
  lodepng_color_mode_init(&state->info_raw);
  lodepng_info_init(&state->info_png);
  state->error = 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x1474b0
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0x147510
movq (%rsp), %rdi
addq $0x90, %rdi
callq 0x13f7a0
movq (%rsp), %rdi
addq $0xb8, %rdi
callq 0x140510
movq (%rsp), %rax
movl $0x1, 0x1f0(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_decode_file(unsigned char**, unsigned int*, unsigned int*, char const*, LodePNGColorType, unsigned int)
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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl %r9d, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq $0x0, (%rax)
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movq 0x38(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x13cd30
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1473fa
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movl 0x24(%rsp), %r9d
movl 0x20(%rsp), %eax
movl %eax, (%rsp)
callq 0x147190
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x13e2d0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_decoder_settings_init(LodePNGDecoderSettings*)
void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings) {
  settings->color_convert = 1;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->read_text_chunks = 1;
  settings->remember_unknown_chunks = 0;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  settings->ignore_crc = 0;
  settings->ignore_critical = 0;
  settings->ignore_end = 0;
  lodepng_decompress_settings_init(&settings->zlibsettings);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x1, 0x2c(%rax)
movq (%rsp), %rax
movl $0x1, 0x30(%rax)
movq (%rsp), %rax
movl $0x0, 0x34(%rax)
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq (%rsp), %rax
movl $0x0, 0x24(%rax)
movq (%rsp), %rax
movl $0x0, 0x28(%rax)
movq (%rsp), %rdi
callq 0x13edb0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_encoder_settings_init(LodePNGEncoderSettings*)
void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings) {
  lodepng_compress_settings_init(&settings->zlibsettings);
  settings->filter_palette_zero = 1;
  settings->filter_strategy = LFS_MINSUM;
  settings->auto_convert = 1;
  settings->force_palette = 0;
  settings->predefined_filters = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->add_id = 0;
  settings->text_compression = 1;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x13ed30
movq (%rsp), %rax
movl $0x1, 0x34(%rax)
movq (%rsp), %rax
movl $0x5, 0x38(%rax)
movq (%rsp), %rax
movl $0x1, 0x30(%rax)
movq (%rsp), %rax
movl $0x0, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movl $0x0, 0x4c(%rax)
movq (%rsp), %rax
movl $0x1, 0x50(%rax)
popq %rax
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: isGrayICCProfile(unsigned char const*, unsigned int)
static unsigned isGrayICCProfile(const unsigned char* profile, unsigned size) {
  /*
  It is a gray profile if bytes 16-19 are "GRAY", rgb profile if bytes 16-19
  are "RGB ". We do not perform any full parsing of the ICC profile here, other
  than check those 4 bytes to grayscale profile. Other than that, validity of
  the profile is not checked. This is needed only because the PNG specification
  requires using a non-gray color model if there is an ICC profile with "RGB "
  (sadly limiting compression opportunities if the input data is grayscale RGB
  data), and requires using a gray color model if it is "GRAY".
  */
  if(size < 20) return 0;
  return profile[16] == 'G' &&  profile[17] == 'R' &&  profile[18] == 'A' &&  profile[19] == 'Y';
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x14, -0x14(%rsp)
jae 0x14848a
movl $0x0, -0x4(%rsp)
jmp 0x1484e6
movq -0x10(%rsp), %rax
movzbl 0x10(%rax), %ecx
xorl %eax, %eax
cmpl $0x47, %ecx
movb %al, -0x15(%rsp)
jne 0x1484d9
movq -0x10(%rsp), %rax
movzbl 0x11(%rax), %ecx
xorl %eax, %eax
cmpl $0x52, %ecx
movb %al, -0x15(%rsp)
jne 0x1484d9
movq -0x10(%rsp), %rax
movzbl 0x12(%rax), %ecx
xorl %eax, %eax
cmpl $0x41, %ecx
movb %al, -0x15(%rsp)
jne 0x1484d9
movq -0x10(%rsp), %rax
movzbl 0x13(%rax), %eax
cmpl $0x59, %eax
sete %al
movb %al, -0x15(%rsp)
movb -0x15(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_color_stats_add(LodePNGColorStats*, unsigned int, unsigned int, unsigned int, unsigned int)
static void lodepng_color_stats_add(LodePNGColorStats* stats,
                                    unsigned r, unsigned g, unsigned b, unsigned a) {
  unsigned char image[8];
  LodePNGColorMode mode;
  lodepng_color_mode_init(&mode);
  image[0] = r >> 8; image[1] = r; image[2] = g >> 8; image[3] = g;
  image[4] = b >> 8; image[5] = b; image[6] = a >> 8; image[7] = a;
  mode.bitdepth = 16;
  mode.colortype = LCT_RGBA;
  lodepng_compute_color_stats(stats, image, 1, 1, &mode);
  lodepng_color_mode_cleanup(&mode);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movq %rsp, %rdi
callq 0x13f7a0
movl 0x3c(%rsp), %eax
shrl $0x8, %eax
movb %al, 0x28(%rsp)
movl 0x3c(%rsp), %eax
movb %al, 0x29(%rsp)
movl 0x38(%rsp), %eax
shrl $0x8, %eax
movb %al, 0x2a(%rsp)
movl 0x38(%rsp), %eax
movb %al, 0x2b(%rsp)
movl 0x34(%rsp), %eax
shrl $0x8, %eax
movb %al, 0x2c(%rsp)
movl 0x34(%rsp), %eax
movb %al, 0x2d(%rsp)
movl 0x30(%rsp), %eax
shrl $0x8, %eax
movb %al, 0x2e(%rsp)
movl 0x30(%rsp), %eax
movb %al, 0x2f(%rsp)
movl $0x10, 0x4(%rsp)
movl $0x6, (%rsp)
movq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x1, %ecx
movq %rsp, %r8
movl %ecx, %edx
callq 0x1436e0
movq %rsp, %rdi
callq 0x13f8d0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addChunk_IHDR(ucvector*, unsigned int, unsigned int, LodePNGColorType, unsigned int, unsigned int)
static unsigned addChunk_IHDR(ucvector* out, unsigned w, unsigned h,
                              LodePNGColorType colortype, unsigned bitdepth, unsigned interlace_method) {
  unsigned char data[13];

  lodepng_set32bitInt(data + 0, w); /*width*/
  lodepng_set32bitInt(data + 4, h); /*height*/
  data[8] = (unsigned char)bitdepth; /*bit depth*/
  data[9] = (unsigned char)colortype; /*color type*/
  data[10] = 0; /*compression method*/
  data[11] = 0; /*filter method*/
  data[12] = interlace_method; /*interlace method*/

  return addChunk(out, "IHDR", data, sizeof(data));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
leaq 0xf(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x13ecd0
leaq 0xf(%rsp), %rdi
addq $0x4, %rdi
movl 0x28(%rsp), %esi
callq 0x13ecd0
movl 0x20(%rsp), %eax
movb %al, 0x17(%rsp)
movl 0x24(%rsp), %eax
movb %al, 0x18(%rsp)
movb $0x0, 0x19(%rsp)
movb $0x0, 0x1a(%rsp)
movl 0x1c(%rsp), %eax
movb %al, 0x1b(%rsp)
movq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
leaq 0x2d706(%rip), %rsi     # 0x1766c8
movl $0xd, %ecx
callq 0x1532d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addUnknownChunks(ucvector*, unsigned char*, unsigned long)
static unsigned addUnknownChunks(ucvector* out, unsigned char* data, size_t datasize) {
  unsigned char* inchunk = data;
  while((size_t)(inchunk - data) < datasize) {
    CERROR_TRY_RETURN(lodepng_chunk_append(&out->data, &out->size, inchunk));
    out->allocsize = out->size; /*fix the allocsize again*/
    inchunk = lodepng_chunk_next(inchunk, data + datasize);
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
cmpq 0x18(%rsp), %rax
jae 0x14906b
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
movq 0x10(%rsp), %rdx
callq 0x13f4d0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x14903e
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x149073
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq 0x18(%rsp), %rsi
callq 0x13f130
movq %rax, 0x10(%rsp)
jmp 0x148ffd
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addChunk_iCCP(ucvector*, LodePNGInfo const*, LodePNGCompressSettings*)
static unsigned addChunk_iCCP(ucvector* out, const LodePNGInfo* info, LodePNGCompressSettings* zlibsettings) {
  unsigned error = 0;
  ucvector data, compressed;
  size_t i;

  ucvector_init(&data);
  ucvector_init(&compressed);
  for(i = 0; info->iccp_name[i] != 0; ++i) ucvector_push_back(&data, (unsigned char)info->iccp_name[i]);
  if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/
  ucvector_push_back(&data, 0); /*0 termination char*/
  ucvector_push_back(&data, 0); /*compression method: 0*/

  error = zlib_compress(&compressed.data, &compressed.size,
                        info->iccp_profile, info->iccp_profile_size, zlibsettings);
  if(!error) {
    for(i = 0; i != compressed.size; ++i) ucvector_push_back(&data, compressed.data[i]);
    error = addChunk(out, "iCCP", data.data, data.size);
  }

  ucvector_cleanup(&compressed);
  ucvector_cleanup(&data);
  return error;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x148440
leaq 0x10(%rsp), %rdi
callq 0x148440
movq $0x0, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq 0xf0(%rax), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x149101
movq 0x50(%rsp), %rax
movq 0xf0(%rax), %rax
movq 0x8(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x14e670
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1490b8
cmpq $0x1, 0x8(%rsp)
jb 0x149111
cmpq $0x4f, 0x8(%rsp)
jbe 0x14911e
movl $0x59, 0x64(%rsp)
jmp 0x1491ea
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x14e670
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x14e670
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
addq $0x8, %rsi
movq 0x50(%rsp), %rax
movq 0xf8(%rax), %rdx
movq 0x50(%rsp), %rax
movl 0x100(%rax), %eax
movl %eax, %ecx
movq 0x48(%rsp), %r8
callq 0x14ac70
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x1491ce
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x1491af
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x14e670
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x14917b
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x2d53f(%rip), %rsi     # 0x176704
callq 0x1532d0
movl %eax, 0x44(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x14ff20
leaq 0x28(%rsp), %rdi
callq 0x14ff20
movl 0x44(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addChunk_cHRM(ucvector*, LodePNGInfo const*)
static unsigned addChunk_cHRM(ucvector* out, const LodePNGInfo* info) {
  unsigned char data[32];
  lodepng_set32bitInt(data + 0, info->chrm_white_x);
  lodepng_set32bitInt(data + 4, info->chrm_white_y);
  lodepng_set32bitInt(data + 8, info->chrm_red_x);
  lodepng_set32bitInt(data + 12, info->chrm_red_y);
  lodepng_set32bitInt(data + 16, info->chrm_green_x);
  lodepng_set32bitInt(data + 20, info->chrm_green_y);
  lodepng_set32bitInt(data + 24, info->chrm_blue_x);
  lodepng_set32bitInt(data + 28, info->chrm_blue_y);
  return addChunk(out, "cHRM", data, sizeof(data));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rsp, %rdi
movq 0x28(%rsp), %rax
movl 0xc0(%rax), %esi
callq 0x13ecd0
movq %rsp, %rdi
addq $0x4, %rdi
movq 0x28(%rsp), %rax
movl 0xc4(%rax), %esi
callq 0x13ecd0
movq %rsp, %rdi
addq $0x8, %rdi
movq 0x28(%rsp), %rax
movl 0xc8(%rax), %esi
callq 0x13ecd0
movq %rsp, %rdi
addq $0xc, %rdi
movq 0x28(%rsp), %rax
movl 0xcc(%rax), %esi
callq 0x13ecd0
movq %rsp, %rdi
addq $0x10, %rdi
movq 0x28(%rsp), %rax
movl 0xd0(%rax), %esi
callq 0x13ecd0
movq %rsp, %rdi
addq $0x14, %rdi
movq 0x28(%rsp), %rax
movl 0xd4(%rax), %esi
callq 0x13ecd0
movq %rsp, %rdi
addq $0x18, %rdi
movq 0x28(%rsp), %rax
movl 0xd8(%rax), %esi
callq 0x13ecd0
movq %rsp, %rdi
addq $0x1c, %rdi
movq 0x28(%rsp), %rax
movl 0xdc(%rax), %esi
callq 0x13ecd0
movq 0x30(%rsp), %rdi
movq %rsp, %rdx
leaq 0x2d399(%rip), %rsi     # 0x1766fa
movl $0x20, %ecx
callq 0x1532d0
addq $0x38, %rsp
retq
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addChunk_bKGD(ucvector*, LodePNGInfo const*)
static unsigned addChunk_bKGD(ucvector* out, const LodePNGInfo* info) {
  unsigned char data[6];
  size_t size = 0;
  if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA) {
    data[0] = (unsigned char)(info->background_r >> 8);
    data[1] = (unsigned char)(info->background_r & 255);
    size = 2;
  } else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA) {
    data[0] = (unsigned char)(info->background_r >> 8);
    data[1] = (unsigned char)(info->background_r & 255);
    data[2] = (unsigned char)(info->background_g >> 8);
    data[3] = (unsigned char)(info->background_g & 255);
    data[4] = (unsigned char)(info->background_b >> 8);
    data[5] = (unsigned char)(info->background_b & 255);
    size = 6;
  } else if(info->color.colortype == LCT_PALETTE) {
    data[0] =(unsigned char)(info->background_r & 255); /*palette index*/
    size = 1;
  }
  return addChunk(out, "bKGD", data, size);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1497dd
movq 0x18(%rsp), %rax
cmpl $0x4, 0x10(%rax)
jne 0x14980b
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %eax
shrl $0x8, %eax
movb %al, 0x12(%rsp)
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
movb %al, 0x13(%rsp)
movq $0x2, 0x8(%rsp)
jmp 0x1498b5
movq 0x18(%rsp), %rax
cmpl $0x2, 0x10(%rax)
je 0x149821
movq 0x18(%rsp), %rax
cmpl $0x6, 0x10(%rax)
jne 0x14988c
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %eax
shrl $0x8, %eax
movb %al, 0x12(%rsp)
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
movb %al, 0x13(%rsp)
movq 0x18(%rsp), %rax
movl 0x40(%rax), %eax
shrl $0x8, %eax
movb %al, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x40(%rax), %eax
andl $0xff, %eax
movb %al, 0x15(%rsp)
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
shrl $0x8, %eax
movb %al, 0x16(%rsp)
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
andl $0xff, %eax
movb %al, 0x17(%rsp)
movq $0x6, 0x8(%rsp)
jmp 0x1498b3
movq 0x18(%rsp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x1498b1
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
movb %al, 0x12(%rsp)
movq $0x1, 0x8(%rsp)
jmp 0x1498b3
jmp 0x1498b5
movq 0x20(%rsp), %rdi
leaq 0x12(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x2ce0c(%rip), %rsi     # 0x1766d7
callq 0x1532d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addChunk_pHYs(ucvector*, LodePNGInfo const*)
static unsigned addChunk_pHYs(ucvector* out, const LodePNGInfo* info) {
  unsigned char data[9];
  lodepng_set32bitInt(data + 0, info->phys_x);
  lodepng_set32bitInt(data + 4, info->phys_y);  data[8] = info->phys_unit;
  return addChunk(out, "pHYs", data, sizeof(data));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0xf(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0xa8(%rax), %esi
callq 0x13ecd0
leaq 0xf(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rax
movl 0xac(%rax), %esi
callq 0x13ecd0
movq 0x18(%rsp), %rax
movl 0xb0(%rax), %eax
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
leaq 0x2cdb4(%rip), %rsi     # 0x1766f0
movl $0x9, %ecx
callq 0x1532d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addChunk_tIME(ucvector*, LodePNGTime const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time) {
  unsigned char data[7];
  data[0] = (unsigned char)(time->year >> 8);
  data[1] = (unsigned char)(time->year & 255);
  data[2] = (unsigned char)time->month;
  data[3] = (unsigned char)time->day;
  data[4] = (unsigned char)time->hour;
  data[5] = (unsigned char)time->minute;
  data[6] = (unsigned char)time->second;
  return addChunk(out, "tIME", data, sizeof(data));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movb %al, 0x1(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, 0x2(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movb %al, 0x3(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movb %al, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movb %al, 0x5(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movb %al, 0x6(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1(%rsp), %rdx
leaq 0x2cc92(%rip), %rsi     # 0x1766eb
movl $0x7, %ecx
callq 0x1532d0
addq $0x18, %rsp
retq
nopl (%rax,%rax)