LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_append_chunk(unsigned char**, unsigned long*, unsigned char const*)
unsigned LodePNG_append_chunk(unsigned char** out, size_t* outlength, const unsigned char* chunk) /*appends chunk that was already created, to the data. Returns error code.*/
{
  unsigned i;
  unsigned total_chunk_length = LodePNG_chunk_length(chunk) + 12;
  unsigned char *chunk_start, *new_buffer;
  size_t new_length = (*outlength) + total_chunk_length;
  if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/
  
  new_buffer = (unsigned char*)realloc(*out, new_length);
  if(!new_buffer) return 9929;
  (*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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25a30
addl $0xc, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x28(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
cmpq %rcx, %rax
jb 0x25e2d
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x25e39
movl $0x4d, -0x4(%rbp)
jmp 0x25ec0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x5650
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x25e5d
movl $0x26c9, -0x4(%rbp)     # imm = 0x26C9
jmp 0x25ec0
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movl -0x28(%rbp), %edx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x25eb9
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25e92
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_create_chunk(unsigned char**, unsigned long*, unsigned int, char const*, unsigned char const*)
unsigned LodePNG_create_chunk(unsigned char** out, size_t* outlength, unsigned length, const char* type, const unsigned char* data) /*appends new chunk to out. Returns error code; may change memory address of out buffer*/
{
  unsigned i;
  unsigned char *chunk, *new_buffer;
  size_t new_length = (*outlength) + length + 12;
  if(new_length < length + 12 || new_length < (*outlength)) return 77; /*integer overflow happened*/
  new_buffer = (unsigned char*)realloc(*out, new_length);
  if(!new_buffer) return 9930;
  (*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] = type[0];
  chunk[5] = type[1];
  chunk[6] = type[2];
  chunk[7] = 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x25f1e
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x25f2a
movl $0x4d, -0x4(%rbp)
jmp 0x2600c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x50(%rbp), %rsi
callq 0x5650
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x25f51
movl $0x26ca, -0x4(%rbp)     # imm = 0x26CA
jmp 0x2600c
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
subq %rdx, %rcx
subq $0xc, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x25d20
movq -0x28(%rbp), %rax
movb (%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x28(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x28(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x28(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x7(%rax)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x25ffc
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x8, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x25fd0
movq -0x40(%rbp), %rdi
callq 0x25cd0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_InfoColor_init(LodePNG_InfoColor*)
void LodePNG_InfoColor_init(LodePNG_InfoColor* info)
{
  info->key_defined = 0;
  info->key_r = info->key_g = info->key_b = 0;
  info->colorType = 6;
  info->bitDepth = 8;
  info->palette = 0;
  info->palettesize = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x6, (%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_InfoColor_addPalette(LodePNG_InfoColor*, unsigned char, unsigned char, unsigned char, unsigned char)
unsigned LodePNG_InfoColor_addPalette(LodePNG_InfoColor* info, unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  unsigned char* data;
  /*the same resize technique as C++ std::vectors is used, and here it's made so that for a palette with the max of 256 colors, it'll have the exact alloc size*/
  if(!(info->palettesize & (info->palettesize - 1))) /*if palettesize is 0 or a power of two*/
  {
    /*allocated data must be at least 4* palettesize (for 4 color bytes)*/
    size_t alloc_size = info->palettesize == 0 ? 4 : info->palettesize * 4 * 2;
    data = (unsigned char*)realloc(info->palette, alloc_size);
    if(!data) return 9931;
    else info->palette = data;
  }
  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 $0x30, %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
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x26190
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2613f
movl $0x4, %eax
movq %rax, -0x30(%rbp)
jmp 0x26152
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x5650
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x26182
movl $0x26cb, -0x4(%rbp)     # imm = 0x26CB
jmp 0x26212
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x26190
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 $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: getNumColorChannels(unsigned int)
static unsigned getNumColorChannels(unsigned colorType)
{
  switch(colorType)
  {
    case 0: return 1; /*grey*/
    case 2: return 3; /*RGB*/
    case 3: return 1; /*palette*/
    case 4: return 2; /*grey + alpha*/
    case 6: return 4; /*RGBA*/
  }
  return 0; /*unexisting color type*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x6, %rax
ja 0x262e5
movq -0x10(%rbp), %rax
leaq 0x25511(%rip), %rcx     # 0x4b7c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x262ec
movl $0x3, -0x4(%rbp)
jmp 0x262ec
movl $0x1, -0x4(%rbp)
jmp 0x262ec
movl $0x2, -0x4(%rbp)
jmp 0x262ec
movl $0x4, -0x4(%rbp)
jmp 0x262ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_UnknownChunks_copy(LodePNG_UnknownChunks*, LodePNG_UnknownChunks const*)
unsigned LodePNG_UnknownChunks_copy(LodePNG_UnknownChunks* dest, const LodePNG_UnknownChunks* src)
{
  unsigned i;
  
  LodePNG_UnknownChunks_cleanup(dest);
  
  for(i = 0; i < 3; i++)
  {
    size_t j;
    dest->datasize[i] = src->datasize[i];
    dest->data[i] = (unsigned char*)malloc(src->datasize[i]);
    if(!dest->data[i] && dest->datasize[i]) return 9932;
    for(j = 0; j < src->datasize[i]; j++) dest->data[i][j] = src->data[i][j];
  }
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x263f0
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jae 0x26513
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x5570
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x264b7
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, 0x18(%rax,%rcx,8)
je 0x264b7
movl $0x26cc, -0x4(%rbp)     # imm = 0x26CC
jmp 0x2651a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
cmpq 0x18(%rcx,%rdx,8), %rax
jae 0x26503
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x264bf
jmp 0x26505
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26450
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_Text_clear(LodePNG_Text*)
void LodePNG_Text_clear(LodePNG_Text* text)
{
  size_t i;
  for(i = 0; i < text->num; i++)
    {
    string_cleanup(&text->keys[i]);
    string_cleanup(&text->strings[i]);
    }
  free(text->keys);
  free(text->strings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x265df
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x267f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x267f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x26594
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x54b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_Text_copy(LodePNG_Text*, LodePNG_Text const*)
unsigned LodePNG_Text_copy(LodePNG_Text* dest, const LodePNG_Text* source)
{
  size_t i = 0;
  dest->keys = 0;
  dest->strings = 0;
  dest->num = 0;
  for(i = 0; i < source->num; i++)
  {
    unsigned error = LodePNG_Text_add(dest, source->keys[i], source->strings[i]);
    if(error) return error;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2669a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x266b0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2668a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x266a1
jmp 0x2668c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26643
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_Text_add(LodePNG_Text*, char const*, char const*)
unsigned LodePNG_Text_add(LodePNG_Text* text, const char* key, const char* str)
{
  char** new_keys = (char**)(realloc(text->keys, sizeof(char*) * (text->num + 1)));
  char** new_strings = (char**)(realloc(text->strings, sizeof(char*) * (text->num + 1)));
  if(!new_keys || !new_strings)
  {
    free(new_keys);
    free(new_strings);
    return 9933;
  }
  
  text->num++;
  text->keys = new_keys;
  text->strings = new_strings;
  
  string_init(&text->keys[text->num - 1]);
  string_set(&text->keys[text->num - 1], key);
  
  string_init(&text->strings[text->num - 1]);
  string_set(&text->strings[text->num - 1], str);
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x5650
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x5650
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x26712
cmpq $0x0, -0x30(%rbp)
jne 0x26730
movq -0x28(%rbp), %rdi
callq 0x54b0
movq -0x30(%rbp), %rdi
callq 0x54b0
movl $0x26cd, -0x4(%rbp)     # imm = 0x26CD
jmp 0x267e1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x26820
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x26850
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x26820
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x26850
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_IText_init(LodePNG_IText*)
void LodePNG_IText_init(LodePNG_IText* text)
{
  text->num = 0;
  text->keys = NULL;
  text->langtags = NULL;
  text->transkeys = NULL;
  text->strings = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%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)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_IText_clear(LodePNG_IText*)
void LodePNG_IText_clear(LodePNG_IText* text)
{
  size_t i;
  for(i = 0; i < text->num; i++)
    {
    string_cleanup(&text->keys[i]);
    string_cleanup(&text->langtags[i]);
    string_cleanup(&text->transkeys[i]);
    string_cleanup(&text->strings[i]);
    }
  free(text->keys);
  free(text->langtags);
  free(text->transkeys);
  free(text->strings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x269cf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x267f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x267f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x267f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x267f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x26954
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x54b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x54b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x54b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_IText_copy(LodePNG_IText*, LodePNG_IText const*)
unsigned LodePNG_IText_copy(LodePNG_IText* dest, const LodePNG_IText* source)
{
  size_t i = 0;
  dest->keys = 0;
  dest->langtags = 0;
  dest->transkeys = 0;
  dest->strings = 0;
  dest->num = 0;
  for(i = 0; i < source->num; i++)
  {
    unsigned error = LodePNG_IText_add(dest, source->keys[i], source->langtags[i], source->transkeys[i], source->strings[i]);
    if(error) return error;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x26ae2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %r8
movq (%rax,%r8,8), %r8
callq 0x26b00
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x26ad2
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26ae9
jmp 0x26ad4
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26a6b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_InfoPng_init(LodePNG_InfoPng*)
void LodePNG_InfoPng_init(LodePNG_InfoPng* info)
{
  info->width = info->height = 0;
  LodePNG_InfoColor_init(&info->color);
  info->interlaceMethod = 0;
  info->compressionMethod = 0;
  info->filterMethod = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  info->background_defined = 0;
  info->background_r = info->background_g = info->background_b = 0;
  
  LodePNG_Text_init(&info->text);
  LodePNG_IText_init(&info->itext);
  
  info->time_defined = 0;
  info->phys_defined = 0;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
  LodePNG_UnknownChunks_init(&info->unknown_chunks);
#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x26020
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x26530
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x268d0
movq -0x8(%rbp), %rax
movb $0x0, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
callq 0x26390
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_InfoPng_cleanup(LodePNG_InfoPng*)
void LodePNG_InfoPng_cleanup(LodePNG_InfoPng* info)
{
  LodePNG_InfoColor_cleanup(&info->color);
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  LodePNG_Text_cleanup(&info->text);
  LodePNG_IText_cleanup(&info->itext);
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
  LodePNG_UnknownChunks_cleanup(&info->unknown_chunks);
#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x26090
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x26560
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x26920
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
callq 0x263f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_InfoPng_copy(LodePNG_InfoPng*, LodePNG_InfoPng const*)
unsigned LodePNG_InfoPng_copy(LodePNG_InfoPng* dest, const LodePNG_InfoPng* source)
{
  unsigned error = 0;
  LodePNG_InfoPng_cleanup(dest);
  *dest = *source;
  LodePNG_InfoColor_init(&dest->color);
  error = LodePNG_InfoColor_copy(&dest->color, &source->color); if(error) return error;
  
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  error = LodePNG_Text_copy(&dest->text, &source->text); if(error) return error;
  error = LodePNG_IText_copy(&dest->itext, &source->itext); if(error) return error;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  
#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
  LodePNG_UnknownChunks_init(&dest->unknown_chunks);
  error = LodePNG_UnknownChunks_copy(&dest->unknown_chunks, &source->unknown_chunks); if(error) return error;
#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26e10
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0xe0, %edx
callq 0x5320
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x26020
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x26f60
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x26ec8
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26f56
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
callq 0x26600
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x26eee
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26f56
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
addq $0x68, %rsi
callq 0x26a10
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x26f14
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26f56
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
callq 0x26390
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
movq -0x18(%rbp), %rsi
addq $0xb0, %rsi
callq 0x26430
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x26f50
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26f56
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_InfoColor_copy(LodePNG_InfoColor*, LodePNG_InfoColor const*)
unsigned LodePNG_InfoColor_copy(LodePNG_InfoColor* dest, const LodePNG_InfoColor* source)
{
  size_t i;
  LodePNG_InfoColor_cleanup(dest);
  *dest = *source;
  dest->palette = (unsigned char*)malloc(source->palettesize * 4);
  if(!dest->palette && source->palettesize) return 9935;
  for(i = 0; i < source->palettesize * 4; i++) dest->palette[i] = source->palette[i];
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26090
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x28, %edx
callq 0x5320
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x5570
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x26fc6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x26fc6
movl $0x26cf, -0x4(%rbp)     # imm = 0x26CF
jmp 0x27016
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jae 0x2700f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26fce
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_InfoRaw_copy(LodePNG_InfoRaw*, LodePNG_InfoRaw const*)
unsigned LodePNG_InfoRaw_copy(LodePNG_InfoRaw* dest, const LodePNG_InfoRaw* source)
{
  unsigned error = 0;
  LodePNG_InfoRaw_cleanup(dest);
  *dest = *source;
  LodePNG_InfoColor_init(&dest->color);
  error = LodePNG_InfoColor_copy(&dest->color, &source->color); if(error) return error;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x270a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x28, %edx
callq 0x5320
movq -0x10(%rbp), %rdi
callq 0x26020
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26f60
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x27119
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2711f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: checkColorValidity(unsigned int, unsigned int)
static unsigned checkColorValidity(unsigned colorType, unsigned bd) /*bd = bitDepth*/
{
  switch(colorType)
  {
    case 0: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) return 37; break; /*grey*/
    case 2: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*RGB*/
    case 3: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8            )) return 37; break; /*palette*/
    case 4: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*grey + alpha*/
    case 6: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*RGBA*/
    default: return 31;
  }
  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
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x28270
movq -0x18(%rbp), %rax
leaq 0x2363e(%rip), %rcx     # 0x4b814
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, -0xc(%rbp)
je 0x28206
cmpl $0x2, -0xc(%rbp)
je 0x28206
cmpl $0x4, -0xc(%rbp)
je 0x28206
cmpl $0x8, -0xc(%rbp)
je 0x28206
cmpl $0x10, -0xc(%rbp)
je 0x28206
movl $0x25, -0x4(%rbp)
jmp 0x28280
jmp 0x28279
cmpl $0x8, -0xc(%rbp)
je 0x2821d
cmpl $0x10, -0xc(%rbp)
je 0x2821d
movl $0x25, -0x4(%rbp)
jmp 0x28280
jmp 0x28279
cmpl $0x1, -0xc(%rbp)
je 0x28240
cmpl $0x2, -0xc(%rbp)
je 0x28240
cmpl $0x4, -0xc(%rbp)
je 0x28240
cmpl $0x8, -0xc(%rbp)
je 0x28240
movl $0x25, -0x4(%rbp)
jmp 0x28280
jmp 0x28279
cmpl $0x8, -0xc(%rbp)
je 0x28257
cmpl $0x10, -0xc(%rbp)
je 0x28257
movl $0x25, -0x4(%rbp)
jmp 0x28280
jmp 0x28279
cmpl $0x8, -0xc(%rbp)
je 0x2826e
cmpl $0x10, -0xc(%rbp)
je 0x2826e
movl $0x25, -0x4(%rbp)
jmp 0x28280
jmp 0x28279
movl $0x1f, -0x4(%rbp)
jmp 0x28280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_decode32(unsigned char**, unsigned int*, unsigned int*, unsigned char const*, unsigned long)
unsigned LodePNG_decode32(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize)
{
  unsigned error;
  size_t dummy_size;
  LodePNG_Decoder decoder;
  LodePNG_Decoder_init(&decoder);
  LodePNG_decode(&decoder, out, &dummy_size, in, insize);
  error = decoder.error;
  *w = decoder.infoPng.width;
  *h = decoder.infoPng.height;
  LodePNG_Decoder_cleanup(&decoder);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x29a50
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x160(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x28290
movl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x120(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x11c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x160(%rbp), %rdi
callq 0x29aa0
movl -0x2c(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_Decoder_init(LodePNG_Decoder*)
void LodePNG_Decoder_init(LodePNG_Decoder* decoder)
{
  LodePNG_DecodeSettings_init(&decoder->settings);
  LodePNG_InfoRaw_init(&decoder->infoRaw);
  LodePNG_InfoPng_init(&decoder->infoPng);
  decoder->error = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29c30
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x27080
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x26d40
movq -0x8(%rbp), %rax
movl $0x1, 0x120(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_decode32f(unsigned char**, unsigned int*, unsigned int*, char const*)
unsigned LodePNG_decode32f(unsigned char** out, unsigned* w, unsigned* h, const char* filename)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error;
  error = LodePNG_loadFile(&buffer, &buffersize, filename);
  if(!error) error = LodePNG_decode32(out, w, h, buffer, buffersize);
  free(buffer);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x29b30
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x29b1e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x299d0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x54b0
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_loadFile(unsigned char**, unsigned long*, char const*)
unsigned LodePNG_loadFile(unsigned char** out, size_t* outsize, const char* filename) /*designed for loading files from hard disk in a dynamically allocated buffer*/
{
  FILE* file;
  long size;
  
  /*provide some proper output values if error will happen*/
  *out = 0;
  *outsize = 0;

  file = fopen(filename, "rb");
  if(!file) return 78;

  /*get filesize:*/
  fseek(file , 0 , SEEK_END);
  size = ftell(file);
  rewind(file);
  
  /*read contents of the file into the vector*/
  *outsize = 0;
  *out = (unsigned char*)malloc((size_t)size);
  if(size && (*out)) (*outsize) = fread(*out, 1, (size_t)size, file);

  fclose(file);
  if(!(*out) && size) return 80; /*the above malloc failed*/
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rdi
leaq 0x21fe8(%rip), %rsi     # 0x4bb4d
callq 0x54a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x29b81
movl $0x4e, -0x4(%rbp)
jmp 0x29c25
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x5470
movq -0x28(%rbp), %rdi
callq 0x5030
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x50b0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rdi
callq 0x5570
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x29bfb
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x29bfb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x55f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x53a0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29c1e
cmpq $0x0, -0x30(%rbp)
je 0x29c1e
movl $0x50, -0x4(%rbp)
jmp 0x29c25
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_DecodeSettings_init(LodePNG_DecodeSettings*)
void LodePNG_DecodeSettings_init(LodePNG_DecodeSettings* settings)
{
  settings->color_convert = 1;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->readTextChunks = 1;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  settings->ignoreCrc = 0;
#ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
  settings->rememberUnknownChunks = 0;
#endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
  LodeZlib_DecompressSettings_init(&settings->zlibsettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x25a10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_Decoder_copy(LodePNG_Decoder*, LodePNG_Decoder const*)
void LodePNG_Decoder_copy(LodePNG_Decoder* dest, const LodePNG_Decoder* source)
{
  LodePNG_Decoder_cleanup(dest);
  *dest = *source;
  LodePNG_InfoRaw_init(&dest->infoRaw);
  LodePNG_InfoPng_init(&dest->infoPng);
  dest->error = LodePNG_InfoRaw_copy(&dest->infoRaw, &source->infoRaw); if(dest->error) return;
  dest->error = LodePNG_InfoPng_copy(&dest->infoPng, &source->infoPng); if(dest->error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29aa0
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
movl $0x128, %edx            # imm = 0x128
callq 0x5320
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x27080
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x26d40
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x270c0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x120(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x120(%rax)
je 0x29cf5
jmp 0x29d25
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x26e60
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x120(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x120(%rax)
je 0x29d25
jmp 0x29d25
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: writeSignature(ucvector*)
static void writeSignature(ucvector* out)
{
  /*8 bytes PNG signature*/
  ucvector_push_back(out, 137);
  ucvector_push_back(out, 80);
  ucvector_push_back(out, 78);
  ucvector_push_back(out, 71);
  ucvector_push_back(out, 13);
  ucvector_push_back(out, 10);
  ucvector_push_back(out, 26);
  ucvector_push_back(out, 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x89, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl $0x50, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl $0x4e, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl $0x47, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl $0xd, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl $0x1a, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x25570
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: addChunk_IHDR(ucvector*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
static unsigned addChunk_IHDR(ucvector* out, unsigned w, unsigned h, unsigned bitDepth, unsigned colorType, unsigned interlaceMethod)
{
  unsigned error = 0;
  ucvector header;
  ucvector_init(&header);
  
  LodePNG_add32bitInt(&header, w); /*width*/
  LodePNG_add32bitInt(&header, h); /*height*/
  ucvector_push_back(&header, (unsigned char)bitDepth); /*bit depth*/
  ucvector_push_back(&header, (unsigned char)colorType); /*color type*/
  ucvector_push_back(&header, 0); /*compression method*/
  ucvector_push_back(&header, 0); /*filter method*/
  ucvector_push_back(&header, interlaceMethod); /*interlace method*/
  
  error = addChunk(out, "IHDR", header.data, header.size);
  ucvector_cleanup(&header);
  
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x25960
movl -0xc(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x31710
movl -0x10(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x31710
movl -0x14(%rbp), %eax
leaq -0x38(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movl -0x18(%rbp), %eax
leaq -0x38(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x25570
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x25570
movl -0x1c(%rbp), %eax
leaq -0x38(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x20eaa(%rip), %rsi     # 0x4bb85
callq 0x31760
movl %eax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x25990
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/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)
  {
    unsigned error = LodePNG_append_chunk(&out->data, &out->size, inchunk);
    if(error) return error; /*error: not enough memory*/
    out->allocsize = out->size; /*fix the allocsize again*/
    inchunk = LodePNG_chunk_next(inchunk);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpq -0x20(%rbp), %rax
jae 0x2ad72
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdx
callq 0x25de0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2ad53
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ad79
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
callq 0x25d80
movq %rax, -0x28(%rbp)
jmp 0x2ad1c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: isPaletteFullyOpaque(unsigned char const*, unsigned long)
static unsigned isPaletteFullyOpaque(const unsigned char* palette, size_t palettesize) /*palette given in format RGBARGBARGBARGBA...*/
{
  size_t i;
  for(i = 0; i < palettesize; i++)
  {
    if(palette[4 * i + 3] != 255) return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2ae8f
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x2, %rcx
movzbl 0x3(%rax,%rcx), %eax
cmpl $0xff, %eax
je 0x2ae7f
movl $0x0, -0x4(%rbp)
jmp 0x2ae96
jmp 0x2ae81
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2ae54
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: addChunk_bKGD(ucvector*, LodePNG_InfoPng const*)
static unsigned addChunk_bKGD(ucvector* out, const LodePNG_InfoPng* info)
{
  unsigned error = 0;
  ucvector bKGD;
  ucvector_init(&bKGD);
  if(info->color.colorType == 0 || info->color.colorType == 4)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
  }
  else if(info->color.colorType == 2 || info->color.colorType == 6)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_g / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_g % 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_b / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_b % 256));
  }
  else if(info->color.colorType == 3)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256)); /*palette index*/
  }
  
  error = addChunk(out, "bKGD", bKGD.data, bKGD.size);
  ucvector_cleanup(&bKGD);
  
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25960
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x2b064
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x2b097
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
jmp 0x2b161
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18(%rax)
je 0x2b0af
movq -0x10(%rbp), %rax
cmpl $0x6, 0x18(%rax)
jne 0x2b13b
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
jmp 0x2b15f
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0x2b15d
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x25570
jmp 0x2b15f
jmp 0x2b161
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x209f3(%rip), %rsi     # 0x4bb67
callq 0x31760
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25990
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: addChunk_pHYs(ucvector*, LodePNG_InfoPng const*)
static unsigned addChunk_pHYs(ucvector* out, const LodePNG_InfoPng* info)
{
  unsigned error = 0;
  ucvector data;
  ucvector_init(&data);
  
  LodePNG_add32bitInt(&data, info->phys_x);
  LodePNG_add32bitInt(&data, info->phys_y);
  ucvector_push_back(&data, info->phys_unit);
  
  error = addChunk(out, "pHYs", data.data, data.size);
  ucvector_cleanup(&data);
  
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25960
movq -0x10(%rbp), %rax
movl 0xa4(%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0x31710
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0x31710
movq -0x10(%rbp), %rax
leaq -0x30(%rbp), %rdi
movzbl 0xac(%rax), %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x20983(%rip), %rsi     # 0x4bb80
callq 0x31760
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25990
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: addChunk_IDAT(ucvector*, unsigned char const*, unsigned long, LodeZlib_DeflateSettings*)
static unsigned addChunk_IDAT(ucvector* out, const unsigned char* data, size_t datasize, LodeZlib_DeflateSettings* zlibsettings)
{
  ucvector zlibdata;
  unsigned error = 0;
  
  /*compress with the Zlib compressor*/
  ucvector_init(&zlibdata);
  error = LodePNG_compress(&zlibdata.data, &zlibdata.size, data, datasize, zlibsettings);
  if(!error) error = addChunk(out, "IDAT", zlibdata.data, zlibdata.size);
  ucvector_cleanup(&zlibdata);
  
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x25960
leaq -0x38(%rbp), %rdi
leaq -0x38(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x317d0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x2b289
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x208d2(%rip), %rsi     # 0x4bb53
callq 0x31760
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x25990
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: addChunk_tIME(ucvector*, LodePNG_Time const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNG_Time* time)
{
  unsigned error = 0;
  unsigned char* data = (unsigned char*)malloc(7);
  if(!data) return 9948;
  data[0] = (unsigned char)(time->year / 256);
  data[1] = (unsigned char)(time->year % 256);
  data[2] = time->month;
  data[3] = time->day;
  data[4] = time->hour;
  data[5] = time->minute;
  data[6] = time->second;
  error = addChunk(out, "tIME", data, 7);
  free(data);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x7, %edi
callq 0x5570
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2b2d8
movl $0x26dc, -0x4(%rbp)     # imm = 0x26DC
jmp 0x2b36e
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movb 0x4(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rax
movb 0x6(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x18(%rbp), %rax
movb 0x7(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x20829(%rip), %rsi     # 0x4bb7b
movl $0x7, %ecx
callq 0x31760
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x54b0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)