LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: phillip-h[P]fractal-gen/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 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, interlace_method); /*interlace method*/

  error = addChunk(out, "IHDR", header.data, header.size);
  ucvector_cleanup(&header);

  return error;
}

// 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)
movl $0x0, 0x18(%rsp)
movq %rsp, %rdi
callq 0xf580
movl 0x2c(%rsp), %esi
movq %rsp, %rdi
callq 0x82c0
movl 0x28(%rsp), %esi
movq %rsp, %rdi
callq 0x82c0
movl 0x20(%rsp), %eax
movq %rsp, %rdi
movzbl %al, %esi
callq 0x81d0
movl 0x24(%rsp), %eax
movq %rsp, %rdi
movzbl %al, %esi
callq 0x81d0
movq %rsp, %rdi
xorl %esi, %esi
callq 0x81d0
movq %rsp, %rdi
xorl %esi, %esi
callq 0x81d0
movl 0x1c(%rsp), %eax
movq %rsp, %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x30(%rsp), %rdi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0xd1ab(%rip), %rsi      # 0x1c878
callq 0x19c40
movl %eax, 0x18(%rsp)
movq %rsp, %rdi
callq 0x17170
movl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/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);
  }
  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 0xf771
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
movq 0x10(%rsp), %rdx
callq 0x8780
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xf74e
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xf779
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x8720
movq %rax, 0x10(%rsp)
jmp 0xf70d
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_PLTE(ucvector*, LodePNGColorMode const*)
static unsigned addChunk_PLTE(ucvector* out, const LodePNGColorMode* info)
{
  unsigned error = 0;
  size_t i;
  ucvector PLTE;
  ucvector_init(&PLTE);
  for(i = 0; i != info->palettesize * 4; ++i)
  {
    /*add all channels except alpha channel*/
    if(i % 4 != 3) ucvector_push_back(&PLTE, info->palette[i]);
  }
  error = addChunk(out, "PLTE", PLTE.data, PLTE.size);
  ucvector_cleanup(&PLTE);

  return error;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq %rsp, %rdi
callq 0xf580
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
je 0xf809
movq 0x18(%rsp), %rax
andq $0x3, %rax
cmpq $0x3, %rax
je 0xf7f7
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq %rsp, %rdi
movzbl (%rax,%rcx), %esi
callq 0x81d0
jmp 0xf7f9
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xf7b7
movq 0x30(%rsp), %rdi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0xdf4f(%rip), %rsi      # 0x1d76d
callq 0x19c40
movl %eax, 0x24(%rsp)
movq %rsp, %rdi
callq 0x17170
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: getPaletteTranslucency(unsigned char const*, unsigned long)
static unsigned getPaletteTranslucency(const unsigned char* palette, size_t palettesize)
{
  size_t i;
  unsigned key = 0;
  unsigned r = 0, g = 0, b = 0; /*the value of the color with alpha 0, so long as color keying is possible*/
  for(i = 0; i != palettesize; ++i)
  {
    if(!key && palette[4 * i + 3] == 0)
    {
      r = palette[4 * i + 0]; g = palette[4 * i + 1]; b = palette[4 * i + 2];
      key = 1;
      i = (size_t)(-1); /*restart from beginning, to detect earlier opaque colors with key's value*/
    }
    else if(palette[4 * i + 3] != 255) return 2;
    /*when key, no opaque RGB may have key's RGB*/
    else if(key && r == palette[i * 4 + 0] && g == palette[i * 4 + 1] && b == palette[i * 4 + 2]) return 2;
  }
  return key;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x24(%rsp)
movl $0x0, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movl $0x0, -0x30(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
je 0xf99d
cmpl $0x0, -0x24(%rsp)
jne 0xf8fc
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x3(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xf8fc
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x2, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x1(%rax,%rcx), %eax
movl %eax, -0x2c(%rsp)
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x2(%rax,%rcx), %eax
movl %eax, -0x30(%rsp)
movl $0x1, -0x24(%rsp)
movq $-0x1, -0x20(%rsp)
jmp 0xf988
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x3(%rax,%rcx), %eax
cmpl $0xff, %eax
je 0xf923
movl $0x2, -0x4(%rsp)
jmp 0xf9a5
cmpl $0x0, -0x24(%rsp)
je 0xf984
movl -0x28(%rsp), %eax
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rdx
shlq $0x2, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xf984
movl -0x2c(%rsp), %eax
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rdx
shlq $0x2, %rdx
movzbl 0x1(%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xf984
movl -0x30(%rsp), %eax
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rdx
shlq $0x2, %rdx
movzbl 0x2(%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xf984
movl $0x2, -0x4(%rsp)
jmp 0xf9a5
jmp 0xf986
jmp 0xf988
jmp 0xf98a
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xf873
movl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_bKGD(ucvector*, LodePNGInfo const*)
static unsigned addChunk_bKGD(ucvector* out, const LodePNGInfo* info)
{
  unsigned error = 0;
  ucvector bKGD;
  ucvector_init(&bKGD);
  if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r >> 8));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r & 255));
  }
  else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r >> 8));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r & 255));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_g >> 8));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_g & 255));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_b >> 8));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_b & 255));
  }
  else if(info->color.colortype == LCT_PALETTE)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r & 255)); /*palette index*/
  }

  error = addChunk(out, "bKGD", bKGD.data, bKGD.size);
  ucvector_cleanup(&bKGD);

  return error;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xf580
movq 0x28(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0xfc06
movq 0x28(%rsp), %rax
cmpl $0x4, 0x10(%rax)
jne 0xfc3d
movq 0x28(%rsp), %rax
movl 0x3c(%rax), %eax
shrl $0x8, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x28(%rsp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
jmp 0xfd18
movq 0x28(%rsp), %rax
cmpl $0x2, 0x10(%rax)
je 0xfc57
movq 0x28(%rsp), %rax
cmpl $0x6, 0x10(%rax)
jne 0xfcef
movq 0x28(%rsp), %rax
movl 0x3c(%rax), %eax
shrl $0x8, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x28(%rsp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x28(%rsp), %rax
movl 0x40(%rax), %eax
shrl $0x8, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x28(%rsp), %rax
movl 0x40(%rax), %eax
andl $0xff, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x28(%rsp), %rax
movl 0x44(%rax), %eax
shrl $0x8, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x28(%rsp), %rax
movl 0x44(%rax), %eax
andl $0xff, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
jmp 0xfd16
movq 0x28(%rsp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xfd14
movq 0x28(%rsp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
jmp 0xfd16
jmp 0xfd18
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0xda49(%rip), %rsi      # 0x1d777
callq 0x19c40
movl %eax, 0x24(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x17170
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_pHYs(ucvector*, LodePNGInfo const*)
static unsigned addChunk_pHYs(ucvector* out, const LodePNGInfo* 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xf580
movq 0x28(%rsp), %rax
movl 0xa8(%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x82c0
movq 0x28(%rsp), %rax
movl 0xac(%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x82c0
movq 0x28(%rsp), %rax
movl 0xb0(%rax), %eax
leaq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x81d0
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0xd9c8(%rip), %rsi      # 0x1d790
callq 0x19c40
movl %eax, 0x24(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x17170
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_IDAT(ucvector*, unsigned char const*, unsigned long, LodePNGCompressSettings*)
static unsigned addChunk_IDAT(ucvector* out, const unsigned char* data, size_t datasize,
                              LodePNGCompressSettings* zlibsettings)
{
  ucvector zlibdata;
  unsigned error = 0;

  /*compress with the Zlib compressor*/
  ucvector_init(&zlibdata);
  error = zlib_compress(&zlibdata.data, &zlibdata.size, data, datasize, zlibsettings);
  if(!error) error = addChunk(out, "IDAT", zlibdata.data, zlibdata.size);
  ucvector_cleanup(&zlibdata);

  return error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf580
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
addq $0x8, %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x110c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xfe66
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0xd906(%rip), %rsi      # 0x1d763
callq 0x19c40
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x17170
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_tIME(ucvector*, LodePNGTime const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time)
{
  unsigned error = 0;
  unsigned char* data = (unsigned char*)lodepng_malloc(7);
  if(!data) return 83; /*alloc fail*/
  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;
  error = addChunk(out, "tIME", data, 7);
  lodepng_free(data);
  return error;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x7, %edi
callq 0x6cd0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xfeb8
movl $0x53, 0x24(%rsp)
jmp 0xff63
movq 0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x3(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x5(%rax)
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x6(%rax)
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
leaq 0xd847(%rip), %rsi      # 0x1d78b
movl $0x7, %ecx
callq 0x19c40
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
callq 0x78b0
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_zTXt(ucvector*, char const*, char const*, LodePNGCompressSettings*)
static unsigned addChunk_zTXt(ucvector* out, const char* keyword, const char* textstring,
                              LodePNGCompressSettings* zlibsettings)
{
  unsigned error = 0;
  ucvector data, compressed;
  size_t i, textsize = strlen(textstring);

  ucvector_init(&data);
  ucvector_init(&compressed);
  for(i = 0; keyword[i] != 0; ++i) ucvector_push_back(&data, (unsigned char)keyword[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,
                        (unsigned char*)textstring, textsize, zlibsettings);
  if(!error)
  {
    for(i = 0; i != compressed.size; ++i) ucvector_push_back(&data, compressed.data[i]);
    error = addChunk(out, "zTXt", data.data, data.size);
  }

  ucvector_cleanup(&compressed);
  ucvector_cleanup(&data);
  return error;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x58(%rsp), %rdi
callq 0x30d0
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf580
leaq 0x18(%rsp), %rdi
callq 0xf580
movq $0x0, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xfff7
movq 0x60(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x81d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xffbc
cmpq $0x1, 0x10(%rsp)
jb 0x10007
cmpq $0x4f, 0x10(%rsp)
jbe 0x10014
movl $0x59, 0x74(%rsp)
jmp 0x100d1
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x81d0
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x81d0
leaq 0x18(%rsp), %rdi
leaq 0x18(%rsp), %rsi
addq $0x8, %rsi
movq 0x58(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x110c0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x100b5
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x10096
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x81d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x10062
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0xd6d5(%rip), %rsi      # 0x1d781
callq 0x19c40
movl %eax, 0x4c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x17170
leaq 0x30(%rsp), %rdi
callq 0x17170
movl 0x4c(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_tEXt(ucvector*, char const*, char const*)
static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring)
{
  unsigned error = 0;
  size_t i;
  ucvector text;
  ucvector_init(&text);
  for(i = 0; keyword[i] != 0; ++i) ucvector_push_back(&text, (unsigned char)keyword[i]);
  if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/
  ucvector_push_back(&text, 0); /*0 termination char*/
  for(i = 0; textstring[i] != 0; ++i) ucvector_push_back(&text, (unsigned char)textstring[i]);
  error = addChunk(out, "tEXt", text.data, text.size);
  ucvector_cleanup(&text);

  return error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq %rsp, %rdi
callq 0xf580
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x10145
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rsp, %rdi
movzbl (%rax,%rcx), %esi
callq 0x81d0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1010c
cmpq $0x1, 0x18(%rsp)
jb 0x10155
cmpq $0x4f, 0x18(%rsp)
jbe 0x1015f
movl $0x59, 0x44(%rsp)
jmp 0x101d9
movq %rsp, %rdi
xorl %esi, %esi
callq 0x81d0
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x101ab
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rsp, %rdi
movzbl (%rax,%rcx), %esi
callq 0x81d0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x10172
movq 0x38(%rsp), %rdi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0xd5bc(%rip), %rsi      # 0x1d77c
callq 0x19c40
movl %eax, 0x24(%rsp)
movq %rsp, %rdi
callq 0x17170
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_encode_memory(unsigned char**, unsigned long*, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize, const unsigned char* image,
                               unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned error;
  LodePNGState state;
  lodepng_state_init(&state);
  state.info_raw.colortype = colortype;
  state.info_raw.bitdepth = bitdepth;
  state.info_png.color.colortype = colortype;
  state.info_png.color.bitdepth = bitdepth;
  lodepng_encode(out, outsize, image, w, h, &state);
  error = state.error;
  lodepng_state_cleanup(&state);
  return error;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movl 0x200(%rsp), %eax
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movl %ecx, 0x1dc(%rsp)
movl %r8d, 0x1d8(%rsp)
movl %r9d, 0x1d4(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x19cc0
movq 0x10(%rsp), %rdi
callq 0xe330
jmp 0x10538
movl 0x1d4(%rsp), %eax
movl %eax, 0xb8(%rsp)
movl 0x200(%rsp), %eax
movl %eax, 0xbc(%rsp)
movl 0x1d4(%rsp), %eax
movl %eax, 0xf0(%rsp)
movl 0x200(%rsp), %eax
movl %eax, 0xf4(%rsp)
movq 0x1f0(%rsp), %rdi
movq 0x1e8(%rsp), %rsi
movq 0x1e0(%rsp), %rdx
movl 0x1dc(%rsp), %ecx
movl 0x1d8(%rsp), %r8d
leaq 0x28(%rsp), %r9
callq 0xe6f0
jmp 0x105a3
movl 0x1c8(%rsp), %eax
movl %eax, 0x1d0(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xe380
jmp 0x105bd
movl 0x1d0(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x19ce0
movl 0xc(%rsp), %eax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x19ce0
movq 0x20(%rsp), %rdi
callq 0x3390
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_encode_file(char const*, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned lodepng_encode_file(const char* filename, const unsigned char* image, unsigned w, unsigned h,
                             LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error = lodepng_encode_memory(&buffer, &buffersize, image, w, h, colortype, bitdepth);
  if(!error) error = lodepng_save_file(buffer, buffersize, filename);
  lodepng_free(buffer);
  return error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl %r9d, 0x28(%rsp)
movq 0x38(%rsp), %rdx
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %r8d
movl 0x2c(%rsp), %r9d
movl 0x28(%rsp), %eax
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl %eax, (%rsp)
callq 0x104e0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x1070c
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x6d70
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x78b0
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::load_file(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned load_file(std::vector<unsigned char>& buffer, const std::string& filename)
{
  long size = lodepng_filesize(filename.c_str());
  if(size < 0) return 78;
  buffer.resize((size_t)size);
  return size == 0 ? 0 : lodepng_buffer_file(&buffer[0], (size_t)size, filename.c_str());
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30b0
movq %rax, %rdi
callq 0x6c20
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jge 0x10d67
movl $0x4e, 0x34(%rsp)
jmp 0x10dc9
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x19d30
cmpq $0x0, 0x18(%rsp)
jne 0x10d86
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x10dc1
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6340
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x6ce0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decompress(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned long, LodePNGDecompressSettings const&)
unsigned decompress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
                    const LodePNGDecompressSettings& settings)
{
  unsigned char* buffer = 0;
  size_t buffersize = 0;
  unsigned error = zlib_decompress(&buffer, &buffersize, in, insize, &settings);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x10f10
movl %eax, 0x24(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x10f07
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x19ef0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x19f20
movq (%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
addq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rsi
callq 0x19e40
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x78b0
movl 0x24(%rsp), %eax
addq $0x58, %rsp
retq
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, unsigned char const*, unsigned long, LodePNGColorType, unsigned int)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const unsigned char* in,
                size_t insize, LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer;
  unsigned error = lodepng_decode_memory(&buffer, &w, &h, in, insize, colortype, bitdepth);
  if(buffer && !error)
  {
    State state;
    state.info_raw.colortype = colortype;
    state.info_raw.bitdepth = bitdepth;
    size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw);
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movl 0x240(%rsp), %eax
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq %rcx, 0x218(%rsp)
movq %r8, 0x210(%rsp)
movl %r9d, 0x20c(%rsp)
movq 0x228(%rsp), %rsi
movq 0x220(%rsp), %rdx
movq 0x218(%rsp), %rcx
movq 0x210(%rsp), %r8
movl 0x20c(%rsp), %r9d
movl 0x240(%rsp), %eax
leaq 0x200(%rsp), %rdi
movl %eax, (%rsp)
callq 0xe220
movl %eax, 0x1fc(%rsp)
cmpq $0x0, 0x200(%rsp)
je 0x114b7
cmpl $0x0, 0x1fc(%rsp)
jne 0x114b7
leaq 0x50(%rsp), %rdi
callq 0x111c0
movl 0x20c(%rsp), %eax
leaq 0xe0(%rsp), %rdx
movl %eax, 0xe0(%rsp)
movl 0x240(%rsp), %eax
movl %eax, 0xe4(%rsp)
movq 0x228(%rsp), %rax
movl (%rax), %edi
movq 0x220(%rsp), %rax
movl (%rax), %esi
callq 0x8ee0
movq %rax, 0x18(%rsp)
jmp 0x1141f
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x230(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x19ef0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x19f20
movq 0x8(%rsp), %rdi
movq 0x200(%rsp), %rdx
movq 0x48(%rsp), %rax
movq %rdx, %rcx
addq %rax, %rcx
movq 0x30(%rsp), %rsi
callq 0x19e40
movq %rax, 0x10(%rsp)
jmp 0x11478
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x200(%rsp), %rdi
callq 0x78b0
jmp 0x11491
leaq 0x50(%rsp), %rdi
callq 0x11290
jmp 0x114b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11290
jmp 0x114c6
movl 0x1fc(%rsp), %eax
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x40(%rsp), %rdi
callq 0x3390
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, lodepng::State&, unsigned char const*, unsigned long)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
                State& state,
                const unsigned char* in, size_t insize)
{
  unsigned char* buffer = NULL;
  unsigned error = lodepng_decode(&buffer, &w, &h, &state, in, insize);
  if(buffer && !error)
  {
    size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw);
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
  }
  lodepng_free(buffer);
  return error;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
leaq 0x30(%rsp), %rdi
callq 0xd380
movl %eax, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1164e
cmpl $0x0, 0x2c(%rsp)
jne 0x1164e
movq 0x58(%rsp), %rax
movl (%rax), %edi
movq 0x50(%rsp), %rax
movl (%rax), %esi
movq 0x48(%rsp), %rdx
addq $0x90, %rdx
callq 0x8ee0
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
callq 0x19ef0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x19f20
movq (%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
addq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rsi
callq 0x19e40
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x78b0
movl 0x2c(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, LodePNGColorType, unsigned int)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const std::string& filename,
                LodePNGColorType colortype, unsigned bitdepth)
{
  std::vector<unsigned char> buffer;
  unsigned error = load_file(buffer, filename);
  if(error) return error;
  return decode(out, w, h, buffer, colortype, bitdepth);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movl %r9d, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x19f60
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x10d30
movl %eax, 0x14(%rsp)
jmp 0x11766
movl 0x14(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x117a1
movl 0x2c(%rsp), %eax
movl %eax, 0x74(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x117da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5bc0
jmp 0x117ed
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movl 0x4c(%rsp), %r8d
movl 0x48(%rsp), %r9d
leaq 0x30(%rsp), %rcx
callq 0x114d0
movl %eax, 0x4(%rsp)
jmp 0x117ca
movl 0x4(%rsp), %eax
movl %eax, 0x74(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5bc0
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3390
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::encode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned encode(std::vector<unsigned char>& out, const unsigned char* in, unsigned w, unsigned h,
                LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error = lodepng_encode_memory(&buffer, &buffersize, in, w, h, colortype, bitdepth);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movl %r9d, 0x48(%rsp)
movq 0x58(%rsp), %rdx
movl 0x54(%rsp), %ecx
movl 0x50(%rsp), %r8d
movl 0x4c(%rsp), %r9d
movl 0x48(%rsp), %eax
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl %eax, (%rsp)
callq 0x104e0
movl %eax, 0x34(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x118aa
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x19ef0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x19f20
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rsi
callq 0x19e40
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x78b0
movl 0x34(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::encode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned int, unsigned int, lodepng::State&)
unsigned encode(std::vector<unsigned char>& out,
                const unsigned char* in, unsigned w, unsigned h,
                State& state)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error = lodepng_encode(&buffer, &buffersize, in, w, h, &state);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rdx
movl 0x44(%rsp), %ecx
movl 0x40(%rsp), %r8d
movq 0x38(%rsp), %r9
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xe6f0
movl %eax, 0x24(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x11a1c
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x19ef0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x19f20
movq (%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
addq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rsi
callq 0x19e40
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x78b0
movl 0x24(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned encode(const std::string& filename,
                const unsigned char* in, unsigned w, unsigned h,
                LodePNGColorType colortype, unsigned bitdepth)
{
  std::vector<unsigned char> buffer;
  unsigned error = encode(buffer, in, w, h, colortype, bitdepth);
  if(!error) error = save_file(buffer, filename);
  return error;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movl %r9d, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x19f60
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x54(%rsp), %edx
movl 0x50(%rsp), %ecx
movl 0x4c(%rsp), %r8d
movl 0x48(%rsp), %r9d
callq 0x11800
movl %eax, 0x18(%rsp)
jmp 0x11b46
movl 0x18(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x11b8e
movq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x10de0
movl %eax, 0xc(%rsp)
jmp 0x11b6a
movl 0xc(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x11b8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5bc0
jmp 0x11ba9
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5bc0
movl 0x8(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: inflateNoCompression(ucvector*, unsigned char const*, unsigned long*, unsigned long*, unsigned long)
static unsigned inflateNoCompression(ucvector* out, const unsigned char* in, size_t* bp, size_t* pos, size_t inlength)
{
  size_t p;
  unsigned LEN, NLEN, n, error = 0;

  /*go to first boundary of byte*/
  while(((*bp) & 0x7) != 0) ++(*bp);
  p = (*bp) / 8; /*byte position*/

  /*read LEN (2 bytes) and NLEN (2 bytes)*/
  if(p + 4 >= inlength) return 52; /*error, bit pointer will jump past memory*/
  LEN = in[p] + 256u * in[p + 1]; p += 2;
  NLEN = in[p] + 256u * in[p + 1]; p += 2;

  /*check if 16-bit NLEN is really the one's complement of LEN*/
  if(LEN + NLEN != 65535) return 21; /*error: NLEN is not one's complement of LEN*/

  if(!ucvector_resize(out, (*pos) + LEN)) return 83; /*alloc fail*/

  /*read the literal data: LEN bytes are now stored in the out buffer*/
  if(p + LEN > inlength) return 23; /*error: reading outside of in buffer*/
  for(n = 0; n < LEN; ++n) out->data[(*pos)++] = in[p++];

  (*bp) = p * 8;

  return error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl $0x0, (%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x11d17
movq 0x28(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x11cf4
movq 0x28(%rsp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x4, %rax
cmpq 0x18(%rsp), %rax
jb 0x11d45
movl $0x34, 0x44(%rsp)
jmp 0x11e7e
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
movzbl 0x1(%rcx,%rdx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
movzbl 0x1(%rcx,%rdx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x11dc9
movl $0x15, 0x44(%rsp)
jmp 0x11e7e
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movl 0xc(%rsp), %eax
addq %rax, %rsi
callq 0x12310
cmpl $0x0, %eax
jne 0x11df4
movl $0x53, 0x44(%rsp)
jmp 0x11e7e
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0x18(%rsp), %rax
jbe 0x11e11
movl $0x17, 0x44(%rsp)
jmp 0x11e7e
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x11e66
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb (%rax,%rcx), %dl
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x11e19
movq 0x10(%rsp), %rcx
shlq $0x3, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movl (%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: ucvector_reserve(ucvector*, unsigned long)
static unsigned ucvector_reserve(ucvector* p, size_t allocsize)
{
  if(allocsize > p->allocsize)
  {
    size_t newsize = (allocsize > p->allocsize * 2) ? allocsize : (allocsize * 3 / 2);
    void* data = lodepng_realloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = (unsigned char*)data;
    }
    else return 0; /*error: not enough memory*/
  }
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x12404
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jbe 0x123a4
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x123b2
imulq $0x3, 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x8890
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x123f8
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x12402
movl $0x0, 0x34(%rsp)
jmp 0x1240c
jmp 0x12404
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: huffmanDecodeSymbol(unsigned char const*, unsigned long*, HuffmanTree const*, unsigned long)
static unsigned huffmanDecodeSymbol(const unsigned char* in, size_t* bp,
                                    const HuffmanTree* codetree, size_t inbitlength)
{
  unsigned treepos = 0, ct;
  for(;;)
  {
    if(*bp >= inbitlength) return (unsigned)(-1); /*error: end of input memory reached without endcode*/
    /*
    decode the symbol from the tree. The "readBitFromStream" code is inlined in
    the expression below because this is the biggest bottleneck while decoding
    */
    ct = codetree->tree2d[(treepos << 1) + READBIT(*bp, in)];
    ++(*bp);
    if(ct < codetree->numcodes) return ct; /*the symbol is decoded, return it*/
    else treepos = ct - codetree->numcodes; /*symbol not yet decoded, instead move tree position*/

    if(treepos >= codetree->numcodes) return (unsigned)(-1); /*error: it appeared outside the codetree*/
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
cmpq -0x28(%rsp), %rax
jb 0x12b98
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x12c33
movq -0x20(%rsp), %rax
movq (%rax), %rax
movl -0x2c(%rsp), %ecx
shll %ecx
movl %ecx, -0x34(%rsp)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rdx
movq (%rdx), %rdx
shrq $0x3, %rdx
movzbl (%rcx,%rdx), %edx
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
andq $0x7, %rcx
sarl %cl, %edx
movl -0x34(%rsp), %ecx
andl $0x1, %edx
addl %edx, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x30(%rsp), %eax
movq -0x20(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
jae 0x12c06
movl -0x30(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x12c33
movl -0x30(%rsp), %eax
movq -0x20(%rsp), %rcx
subl 0x1c(%rcx), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x20(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0x12c2e
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x12c33
jmp 0x12b7c
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: readBitsFromStream(unsigned long*, unsigned char const*, unsigned long)
static unsigned readBitsFromStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
{
  unsigned result = 0, i;
  for(i = 0; i != nbits; ++i)
  {
    result += ((unsigned)READBIT(*bitpointer, bitstream)) << i;
    ++(*bitpointer);
  }
  return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpq -0x18(%rsp), %rax
je 0x12cba
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
shrq $0x3, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
andq $0x7, %rcx
sarl %cl, %eax
andl $0x1, %eax
movl -0x20(%rsp), %ecx
shll %cl, %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x12c5f
movl -0x1c(%rsp), %eax
retq
nop
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: generateFixedLitLenTree(HuffmanTree*)
static unsigned generateFixedLitLenTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  unsigned* bitlen = (unsigned*)lodepng_malloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned));
  if(!bitlen) return 83; /*alloc fail*/

  /*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/
  for(i =   0; i <= 143; ++i) bitlen[i] = 8;
  for(i = 144; i <= 255; ++i) bitlen[i] = 9;
  for(i = 256; i <= 279; ++i) bitlen[i] = 7;
  for(i = 280; i <= 287; ++i) bitlen[i] = 8;

  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DEFLATE_CODE_SYMBOLS, 15);

  lodepng_free(bitlen);
  return error;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x480, %edi            # imm = 0x480
callq 0x6cd0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12d25
movl $0x53, 0x24(%rsp)
jmp 0x12e10
movl $0x0, 0x14(%rsp)
cmpl $0x8f, 0x14(%rsp)
ja 0x12d54
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x8, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12d2d
movl $0x90, 0x14(%rsp)
cmpl $0xff, 0x14(%rsp)
ja 0x12d83
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x9, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12d5c
movl $0x100, 0x14(%rsp)      # imm = 0x100
cmpl $0x117, 0x14(%rsp)      # imm = 0x117
ja 0x12db2
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x7, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12d8b
movl $0x118, 0x14(%rsp)      # imm = 0x118
cmpl $0x11f, 0x14(%rsp)      # imm = 0x11F
ja 0x12de1
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x8, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12dba
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x120, %edx            # imm = 0x120
movl $0xf, %ecx
callq 0x12ec0
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x78b0
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: generateFixedDistanceTree(HuffmanTree*)
static unsigned generateFixedDistanceTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  unsigned* bitlen = (unsigned*)lodepng_malloc(NUM_DISTANCE_SYMBOLS * sizeof(unsigned));
  if(!bitlen) return 83; /*alloc fail*/

  /*there are 32 distance codes, but 30-31 are unused*/
  for(i = 0; i != NUM_DISTANCE_SYMBOLS; ++i) bitlen[i] = 5;
  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DISTANCE_SYMBOLS, 15);

  lodepng_free(bitlen);
  return error;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x80, %edi
callq 0x6cd0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12e52
movl $0x53, 0x24(%rsp)
jmp 0x12ead
movl $0x0, 0x14(%rsp)
cmpl $0x20, 0x14(%rsp)
je 0x12e7e
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x5, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12e5a
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x20, %edx
movl $0xf, %ecx
callq 0x12ec0
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x78b0
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: HuffmanTree_makeFromLengths(HuffmanTree*, unsigned int const*, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromLengths(HuffmanTree* tree, const unsigned* bitlen,
                                            size_t numcodes, unsigned maxbitlen)
{
  unsigned i;
  tree->lengths = (unsigned*)lodepng_malloc(numcodes * sizeof(unsigned));
  if(!tree->lengths) return 83; /*alloc fail*/
  for(i = 0; i != numcodes; ++i) tree->lengths[i] = bitlen[i];
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->maxbitlen = maxbitlen;
  return HuffmanTree_makeFromLengths2(tree);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x8(%rsp), %rdi
shlq $0x2, %rdi
callq 0x6cd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x12f07
movl $0x53, 0x24(%rsp)
jmp 0x12f66
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpq 0x8(%rsp), %rax
je 0x12f3d
movq 0x10(%rsp), %rax
movl (%rsp), %ecx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x12f0e
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x18(%rsp), %rdi
callq 0x12f70
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: uivector_resizev(uivector*, unsigned long, unsigned int)
static unsigned uivector_resizev(uivector* p, size_t size, unsigned value)
{
  size_t oldsize = p->size, i;
  if(!uivector_resize(p, size)) return 0;
  for(i = oldsize; i < size; ++i) p->data[i] = value;
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x134d0
cmpl $0x0, %eax
jne 0x131ce
movl $0x0, 0x34(%rsp)
jmp 0x13210
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x13208
movl 0x1c(%rsp), %edx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x131d8
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: uivector_reserve(uivector*, unsigned long)
static unsigned uivector_reserve(uivector* p, size_t allocsize)
{
  if(allocsize > p->allocsize)
  {
    size_t newsize = (allocsize > p->allocsize * 2) ? allocsize : (allocsize * 3 / 2);
    void* data = lodepng_realloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = (unsigned*)data;
    }
    else return 0; /*error: not enough memory*/
  }
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x135c4
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jbe 0x13564
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x13572
imulq $0x3, 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x8890
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x135b8
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x135c2
movl $0x0, 0x34(%rsp)
jmp 0x135cc
jmp 0x135c4
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)