LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sile[P]unf/src/unf/unf.cc
// Function: main
int main(int argc, char** argv) {
  if(argc != 2) {
  usage:
    std::cerr << "Usage: unf <D|C|KD|KC>" << std::endl;
    return 1;
  }
  
  UNF::Normalizer norm;

  const char* fs = argv[1];
  UNF::Normalizer::Form form;
  if      (eq(fs,"D"))  form = UNF::Normalizer::FORM_NFD;
  else if (eq(fs,"C"))  form = UNF::Normalizer::FORM_NFC;
  else if (eq(fs,"KD")) form = UNF::Normalizer::FORM_NFKD;
  else if (eq(fs,"KC")) form = UNF::Normalizer::FORM_NFKC;
  else                  goto usage;
    
  std::string line;
  while(std::getline(std::cin,line)) 
    std::cout << norm.normalize(line.c_str(), form) << std::endl;

  return 0;
}

// Assembly:
subq $0x188, %rsp            # imm = 0x188
movl $0x0, 0x184(%rsp)
movl %edi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
cmpl $0x2, 0x180(%rsp)
je 0x23af
jmp 0x237d
movq 0x67c6c(%rip), %rdi     # 0x69ff0
leaq 0x3c89(%rip), %rsi      # 0x6014
callq 0x2130
movq %rax, %rdi
movq 0x67c1e(%rip), %rsi     # 0x69fb8
callq 0x2150
movl $0x1, 0x184(%rsp)
jmp 0x2581
leaq 0x70(%rsp), %rdi
callq 0x25b0
movq 0x178(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x3c56(%rip), %rsi      # 0x602c
callq 0x2320
testb $0x1, %al
jne 0x23e1
jmp 0x23eb
movl $0x0, 0x64(%rsp)
jmp 0x2461
movq 0x68(%rsp), %rdi
leaq 0x3c38(%rip), %rsi      # 0x602f
callq 0x2320
testb $0x1, %al
jne 0x2402
jmp 0x240c
movl $0x1, 0x64(%rsp)
jmp 0x245f
movq 0x68(%rsp), %rdi
leaq 0x3c13(%rip), %rsi      # 0x602b
callq 0x2320
testb $0x1, %al
jne 0x2423
jmp 0x242d
movl $0x2, 0x64(%rsp)
jmp 0x245d
movq 0x68(%rsp), %rdi
leaq 0x3bf5(%rip), %rsi      # 0x602e
callq 0x2320
testb $0x1, %al
jne 0x2444
jmp 0x244e
movl $0x3, 0x64(%rsp)
jmp 0x245b
movl $0x2, 0x60(%rsp)
jmp 0x2559
jmp 0x245d
jmp 0x245f
jmp 0x2461
leaq 0x40(%rsp), %rdi
callq 0x2180
jmp 0x246d
jmp 0x246f
movq 0x67b62(%rip), %rdi     # 0x69fd8
leaq 0x40(%rsp), %rsi
callq 0x2040
movq %rax, 0x28(%rsp)
jmp 0x2487
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21b0
movq %rax, 0x20(%rsp)
jmp 0x24a2
movq 0x20(%rsp), %rax
cmpq $0x0, %rax
je 0x2536
leaq 0x40(%rsp), %rdi
callq 0x2080
movq %rax, 0x18(%rsp)
jmp 0x24c2
movq 0x18(%rsp), %rsi
movl 0x64(%rsp), %edx
leaq 0x70(%rsp), %rdi
callq 0x2740
movq %rax, 0x10(%rsp)
jmp 0x24dc
movq 0x10(%rsp), %rsi
movq 0x67ae0(%rip), %rdi     # 0x69fc8
callq 0x2130
movq %rax, 0x8(%rsp)
jmp 0x24f4
movq 0x8(%rsp), %rdi
movq 0x67ab8(%rip), %rsi     # 0x69fb8
callq 0x2150
jmp 0x2507
jmp 0x246f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x2573
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x20d0
jmp 0x2557
movl $0x0, 0x184(%rsp)
movl $0x1, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x20d0
jmp 0x2555
jmp 0x2559
jmp 0x2573
leaq 0x70(%rsp), %rdi
callq 0x2800
movl 0x60(%rsp), %eax
subl $0x1, %eax
je 0x2581
jmp 0x256e
jmp 0x237d
leaq 0x70(%rsp), %rdi
callq 0x2800
jmp 0x257f
jmp 0x2590
movl 0x184(%rsp), %eax
addq $0x188, %rsp            # imm = 0x188
retq
movq 0x38(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x27f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jp-myk[P]WAVUtil/src/wav_trim.cpp
// Function: main
int main(int argc, char *argv[]){
  if(argc<5){
    std::cout << argv[0] << " WAVFILE OUTWAVFLE START_TIME[sec] END_TIME[sec]" << std::endl;
    exit(0);
  }
  const char* wavFName=argv[1];
  const char* output_wavFName=argv[2];
  float start= 0.0;
  float end  = 1.0;
  start= atof(argv[3]);
  end  = atof(argv[4]);
  WAV wav,outwav;
  int res=0;
  res=wav.Read(wavFName);
  std::cout << "trim!" << std::endl;
  res=SimpleWAV::trim_wav(start, end, wav, outwav); // extra 0.0 - 1.00[sec]
  res=outwav.Write(output_wavFName);
  if(res==0) std::cout << "sucess" << std::endl;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x5327
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x3cd3(%rip), %rdi      # 0x8fd0
callq 0x2100
movq %rax, %rdi
leaq 0x1011(%rip), %rsi      # 0x631d
callq 0x2100
movq %rax, %rdi
movq 0x3ca5(%rip), %rsi      # 0x8fc0
callq 0x2130
xorl %edi, %edi
callq 0x2150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x3f800000, -0x28(%rbp) # imm = 0x3F800000
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2160
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2160
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4420
leaq -0xd8(%rbp), %rdi
callq 0x4420
jmp 0x5390
movl $0x0, -0xe8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2e80
movl %eax, -0xec(%rbp)
jmp 0x53af
movl -0xec(%rbp), %eax
movl %eax, -0xe8(%rbp)
movq 0x3c0e(%rip), %rdi      # 0x8fd0
leaq 0xf85(%rip), %rsi       # 0x634e
callq 0x2100
movq %rax, -0xf8(%rbp)
jmp 0x53d7
movq -0xf8(%rbp), %rdi
movq 0x3bdb(%rip), %rsi      # 0x8fc0
callq 0x2130
jmp 0x53ec
movss -0x24(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
leaq -0x80(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x3930
movl %eax, -0xfc(%rbp)
jmp 0x540e
movl -0xfc(%rbp), %eax
movl %eax, -0xe8(%rbp)
movq -0x20(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x2a20
movl %eax, -0x100(%rbp)
jmp 0x5432
movl -0x100(%rbp), %eax
movl %eax, -0xe8(%rbp)
cmpl $0x0, -0xe8(%rbp)
jne 0x54ae
movq 0x3b82(%rip), %rdi      # 0x8fd0
leaq 0xeff(%rip), %rsi       # 0x6354
callq 0x2100
movq %rax, -0x108(%rbp)
jmp 0x5463
movq -0x108(%rbp), %rdi
movq 0x3b4f(%rip), %rsi      # 0x8fc0
callq 0x2130
jmp 0x5478
jmp 0x54ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x54d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x44e0
jmp 0x54d6
movl $0x0, -0x4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x44e0
leaq -0x80(%rbp), %rdi
callq 0x44e0
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x44e0
movq -0xe0(%rbp), %rdi
callq 0x2220
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_load_file(unsigned char**, unsigned long*, char const*)
unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename) {
  unsigned error;
  FILE* file = fopen(filename, "rb");
  if(!file) return 78;
  error = lodepng_load_file_(out, outsize, file);
  fclose(file);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xade86(%rip), %rsi     # 0xb1555
callq 0x32c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x36e8
movl $0x4e, -0x4(%rbp)
jmp 0x370b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3720
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3240
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_load_file_(unsigned char**, unsigned long*, _IO_FILE*)
static unsigned lodepng_load_file_(unsigned char** out, size_t* outsize, FILE* file) {
  long size = lodepng_filesize(file);
  if(size < 0) return 78;
  *outsize = (size_t)size;
  *out = (unsigned char*)lodepng_malloc((size_t)size);
  if(!(*out) && size > 0) return 83; /*the above malloc failed*/
  if(fread(*out, 1, *outsize, file) != *outsize) return 78;
  return 0; /*ok*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12390
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x3751
movl $0x4e, -0x4(%rbp)
jmp 0x37be
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x3bc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3789
cmpq $0x0, -0x28(%rbp)
jle 0x3789
movl $0x53, -0x4(%rbp)
jmp 0x37be
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x3370
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x37b7
movl $0x4e, -0x4(%rbp)
jmp 0x37be
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_inflate(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
                         const unsigned char* in, size_t insize,
                         const LodePNGDecompressSettings* settings) {
  ucvector v = ucvector_init(*out, *outsize);
  unsigned error = lodepng_inflatev(&v, in, insize, settings);
  *out = v.data;
  *outsize = v.size;
  return error;
}

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

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

  if(error) return error;

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

    if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
    else if(BTYPE == 0) error = inflateNoCompression(out, &reader, settings); /*no compression*/
    else error = inflateHuffmanBlock(out, &reader, BTYPE, settings->max_output_size); /*compression, BTYPE 01 or 10*/
    if(!error && settings->max_output_size && out->size > settings->max_output_size) error = 109;
    if(error) break;
  }

  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x12420
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x4334
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4417
jmp 0x4336
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4348
jmp 0x4411
movq -0x48(%rbp), %rax
subq -0x40(%rbp), %rax
cmpq $0x3, %rax
jae 0x4362
movl $0x34, -0x4(%rbp)
jmp 0x4417
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x124c0
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x12590
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x2, %esi
callq 0x12590
movl %eax, -0x60(%rbp)
cmpl $0x3, -0x60(%rbp)
jne 0x43a1
movl $0x14, -0x4(%rbp)
jmp 0x4417
cmpl $0x0, -0x60(%rbp)
jne 0x43bd
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x125d0
movl %eax, -0x5c(%rbp)
jmp 0x43d8
movq -0x10(%rbp), %rdi
movl -0x60(%rbp), %edx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x58(%rbp), %rsi
callq 0x12750
movl %eax, -0x5c(%rbp)
jmp 0x43da
cmpl $0x0, -0x5c(%rbp)
jne 0x4404
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4404
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4404
movl $0x6d, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x440c
jmp 0x4411
jmp 0x4336
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: deflate(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGCompressSettings const*)
static unsigned deflate(unsigned char** out, size_t* outsize,
                        const unsigned char* in, size_t insize,
                        const LodePNGCompressSettings* settings) {
  if(settings->custom_deflate) {
    unsigned error = settings->custom_deflate(out, outsize, in, insize, settings);
    /*the custom deflate is allowed to have its own error codes, however, we translate it to code 111*/
    return error ? 111 : 0;
  } else {
    return lodepng_deflate(out, outsize, in, insize, settings);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4a8d
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edx
xorl %eax, %eax
movl $0x6f, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4aa9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x4420
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_decompress_settings_init(LodePNGDecompressSettings*)
void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings) {
  settings->ignore_adler32 = 0;
  settings->ignore_nlen = 0;
  settings->max_output_size = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nop
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* data, size_t length) {
  /*Using the Slicing by Eight algorithm*/
  unsigned r = 0xffffffffu;
  while(length >= 8) {
    r = lodepng_crc32_table7[(data[0] ^ (r & 0xffu))] ^
        lodepng_crc32_table6[(data[1] ^ ((r >> 8) & 0xffu))] ^
        lodepng_crc32_table5[(data[2] ^ ((r >> 16) & 0xffu))] ^
        lodepng_crc32_table4[(data[3] ^ ((r >> 24) & 0xffu))] ^
        lodepng_crc32_table3[data[4]] ^
        lodepng_crc32_table2[data[5]] ^
        lodepng_crc32_table1[data[6]] ^
        lodepng_crc32_table0[data[7]];
    data += 8;
    length -= 8;
  }
  while(length--) {
    r = lodepng_crc32_table0[(r ^ *data++) & 0xffu] ^ (r >> 8);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
cmpq $0x8, -0x10(%rbp)
jb 0x4d2a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
xorl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xaa635(%rip), %rax     # 0xaf280
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movl -0x14(%rbp), %edx
shrl $0x8, %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0xaaa11(%rip), %rcx     # 0xaf680
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
movl -0x14(%rbp), %edx
shrl $0x10, %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0xaaded(%rip), %rcx     # 0xafa80
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
movl -0x14(%rbp), %edx
shrl $0x18, %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0xab1c9(%rip), %rcx     # 0xafe80
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
movl %ecx, %edx
leaq 0xab5b5(%rip), %rcx     # 0xb0280
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
movl %ecx, %edx
leaq 0xab9a1(%rip), %rcx     # 0xb0680
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
movl %ecx, %edx
leaq 0xabd8d(%rip), %rcx     # 0xb0a80
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movl %ecx, %edx
leaq 0xac179(%rip), %rcx     # 0xb0e80
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x4c23
jmp 0x4d2c
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4d78
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xac118(%rip), %rax     # 0xb0e80
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x4d2c
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
popq %rbp
retq
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_strlen(char const*)
static size_t lodepng_strlen(const char* a) {
  const char* orig = a;
  /* avoid warning about unused function in case of disabled COMPILE... macros */
  (void)(&lodepng_strlen);
  while(*a) a++;
  return (size_t)(a - orig);
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x50a0
cmpq $0xc, -0x20(%rbp)
jae 0x50ad
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x516e
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0x5124
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0x5124
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0x5124
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0x5124
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0x5124
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0x5124
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0x5124
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0x5124
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x516e
movq -0x10(%rbp), %rdi
callq 0x4d80
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x28(%rbp), %rdx
callq 0x5180
cmpl $0x0, %eax
je 0x514e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x516e
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x5162
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x516e
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_next_const(unsigned char const*, unsigned char const*)
const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) {
  size_t available_size = (size_t)(end - chunk);
  if(chunk >= end || available_size < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    if(total_chunk_length > available_size) return end; /*outside of range*/
    return chunk + total_chunk_length;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x51f0
cmpq $0xc, -0x20(%rbp)
jae 0x51fd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x52be
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0x5274
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0x5274
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0x5274
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0x5274
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0x5274
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0x5274
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0x5274
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0x5274
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x52be
movq -0x10(%rbp), %rdi
callq 0x4d80
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x28(%rbp), %rdx
callq 0x5180
cmpl $0x0, %eax
je 0x529e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x52be
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x52b2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x52be
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_append(unsigned char**, unsigned long*, unsigned char const*)
unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk) {
  unsigned i;
  size_t total_chunk_length, new_length;
  unsigned char *chunk_start, *new_buffer;

  if(!lodepng_chunk_type_name_valid(chunk)) {
    return 121; /* invalid chunk type name */
  }
  if(lodepng_chunk_reserved(chunk)) {
    return 122; /* invalid third lowercase character */
  }

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

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

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5500
cmpb $0x0, %al
jne 0x53fd
movl $0x79, -0x4(%rbp)
jmp 0x54ed
movq -0x20(%rbp), %rdi
callq 0x5570
cmpb $0x0, %al
je 0x5416
movl $0x7a, -0x4(%rbp)
jmp 0x54ed
movq -0x20(%rbp), %rdi
callq 0x4d80
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x30(%rbp), %rdx
callq 0x5180
cmpl $0x0, %eax
je 0x5442
movl $0x4d, -0x4(%rbp)
jmp 0x54ed
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5180
cmpl $0x0, %eax
je 0x5467
movl $0x4d, -0x4(%rbp)
jmp 0x54ed
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x5590
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x548b
movl $0x53, -0x4(%rbp)
jmp 0x54ed
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x30(%rbp), %rax
je 0x54e6
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x40(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x54be
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_type_name_valid(unsigned char const*)
static unsigned char lodepng_chunk_type_name_valid(const unsigned char* chunk) {
  unsigned i;
  for(i = 0; i != 4; ++i) {
    char c = (char)chunk[4 + i];
    if(!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
      return 0; /* not valid */
    }
  }
  return 1; /* valid */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
je 0x555e
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x4, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x61, %eax
jl 0x5539
movsbl -0x15(%rbp), %eax
cmpl $0x7a, %eax
jle 0x5551
movsbl -0x15(%rbp), %eax
cmpl $0x41, %eax
jl 0x554b
movsbl -0x15(%rbp), %eax
cmpl $0x5a, %eax
jle 0x5551
movb $0x0, -0x1(%rbp)
jmp 0x5562
jmp 0x5553
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x550f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_createv(ucvector*, unsigned long, char const*, unsigned char const*)
static unsigned lodepng_chunk_createv(ucvector* out,
                                      size_t length, const char* type, const unsigned char* data) {
  unsigned char* chunk;
  CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, length, type));

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

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x167a0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x566e
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5693
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5820
movq -0x30(%rbp), %rdi
callq 0x5020
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_color_mode_copy(LodePNGColorMode*, LodePNGColorMode const*)
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source) {
  lodepng_color_mode_cleanup(dest);
  lodepng_memcpy(dest, source, sizeof(LodePNGColorMode));
  if(source->palette) {
    dest->palette = (unsigned char*)lodepng_malloc(1024);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    lodepng_memcpy(dest->palette, source->palette, source->palettesize * 4);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5710
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x28, %edx
callq 0x5820
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x580b
movl $0x400, %edi            # imm = 0x400
callq 0x3bc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x57ea
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x57ea
movl $0x53, -0x4(%rbp)
jmp 0x5812
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x2, %rdx
callq 0x5820
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_color_mode_make(LodePNGColorType, unsigned int)
LodePNGColorMode lodepng_color_mode_make(LodePNGColorType colortype, unsigned bitdepth) {
  LodePNGColorMode result;
  lodepng_color_mode_init(&result);
  result.colortype = colortype;
  result.bitdepth = bitdepth;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
callq 0x56a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x4(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_color_mode_alloc_palette(LodePNGColorMode*)
static void lodepng_color_mode_alloc_palette(LodePNGColorMode* info) {
  size_t i;
  /*if the palette is already allocated, it will have size 1024 so no reallocation needed in that case*/
  /*the palette must have room for up to 256 colors with 4 bytes each.*/
  if(!info->palette) info->palette = (unsigned char*)lodepng_malloc(1024);
  if(!info->palette) return; /*alloc fail*/
  for(i = 0; i != 256; ++i) {
    /*Initialize all unused colors with black, the value used for invalid palette indices.
    This is an error according to the PNG spec, but common PNG decoders make it black instead.
    That makes color conversion slightly faster due to no error handling needed.*/
    info->palette[i * 4 + 0] = 0;
    info->palette[i * 4 + 1] = 0;
    info->palette[i * 4 + 2] = 0;
    info->palette[i * 4 + 3] = 255;
  }
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x5b17
jmp 0x5ae3
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x5b20
jmp 0x5aed
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x5b29
jmp 0x5af7
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x5b32
jmp 0x5b01
movl -0xc(%rbp), %eax
subl $0x6, %eax
je 0x5b3b
jmp 0x5b0b
movl -0xc(%rbp), %eax
subl $0xff, %eax
je 0x5b44
jmp 0x5b4d
movl $0x1, -0x4(%rbp)
jmp 0x5b54
movl $0x3, -0x4(%rbp)
jmp 0x5b54
movl $0x1, -0x4(%rbp)
jmp 0x5b54
movl $0x2, -0x4(%rbp)
jmp 0x5b54
movl $0x4, -0x4(%rbp)
jmp 0x5b54
movl $0x0, -0x4(%rbp)
jmp 0x5b54
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_add_text_sized(LodePNGInfo*, char const*, char const*, unsigned long)
static unsigned lodepng_add_text_sized(LodePNGInfo* info, const char* key, const char* str, size_t size) {
  char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));

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

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

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x5590
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x5590
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5dcd
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
cmpq $0x0, -0x38(%rbp)
je 0x5de0
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x5dee
cmpq $0x0, -0x38(%rbp)
jne 0x5dfa
movl $0x53, -0x4(%rbp)
jmp 0x5e9c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rdi
callq 0x63e0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16880
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5e8c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x5e95
movl $0x53, -0x4(%rbp)
jmp 0x5e9c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_set_icc(LodePNGInfo*, char const*, unsigned char const*, unsigned int)
unsigned lodepng_set_icc(LodePNGInfo* info, const char* name, const unsigned char* profile, unsigned profile_size) {
  if(info->iccp_defined) lodepng_clear_icc(info);

  if(profile_size == 0) return 100; /*invalid ICC profile size*/

  info->iccp_name = alloc_string(name);
  if(!info->iccp_name) return 83; /*alloc fail*/

  info->iccp_profile = (unsigned char*)lodepng_malloc(profile_size);
  if(!info->iccp_profile) {
    lodepng_free(info->iccp_name);
    return 83; /*alloc fail*/
  }

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

  return 0; /*ok*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xfc(%rax)
je 0x62bd
movq -0x10(%rbp), %rdi
callq 0x6380
cmpl $0x0, -0x24(%rbp)
jne 0x62cf
movl $0x64, -0x4(%rbp)
jmp 0x6377
movq -0x18(%rbp), %rdi
callq 0x63e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x62fd
movl $0x53, -0x4(%rbp)
jmp 0x6377
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x3bc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x108(%rax)
jne 0x633c
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
callq 0x4230
movl $0x53, -0x4(%rbp)
jmp 0x6377
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x5820
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x110(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xfc(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_set_exif(LodePNGInfo*, unsigned char const*, unsigned int)
unsigned lodepng_set_exif(LodePNGInfo* info, const unsigned char* exif, unsigned exif_size) {
  if(info->exif_defined) lodepng_clear_exif(info);
  info->exif = (unsigned char*)lodepng_malloc(exif_size);

  if(!info->exif) return 83; /*alloc fail*/

  lodepng_memcpy(info->exif, exif, exif_size);
  info->exif_size = exif_size;
  info->exif_defined = 1;

  return 0; /*ok*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x6469
movq -0x10(%rbp), %rdi
callq 0x64e0
movl -0x1c(%rbp), %eax
movl %eax, %edi
callq 0x3bc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x6498
movl $0x53, -0x4(%rbp)
jmp 0x64d3
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x5820
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x88(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_clear_exif(LodePNGInfo*)
void lodepng_clear_exif(LodePNGInfo* info) {
  lodepng_free(info->exif);
  info->exif = NULL;
  info->exif_size = 0;
  info->exif_defined = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x4230
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_info_cleanup(LodePNGInfo*)
void lodepng_info_cleanup(LodePNGInfo* info) {
  lodepng_color_mode_cleanup(&info->color);
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  LodePNGText_cleanup(info);
  LodePNGIText_cleanup(info);

  lodepng_clear_icc(info);
  lodepng_clear_exif(info);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x5710
movq -0x8(%rbp), %rdi
callq 0x5ed0
movq -0x8(%rbp), %rdi
callq 0x5f70
movq -0x8(%rbp), %rdi
callq 0x6380
movq -0x8(%rbp), %rdi
callq 0x64e0
movq -0x8(%rbp), %rdi
callq 0x68e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_info_copy(LodePNGInfo*, LodePNGInfo const*)
unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source) {
  lodepng_info_cleanup(dest);
  lodepng_memcpy(dest, source, sizeof(LodePNGInfo));
  lodepng_color_mode_init(&dest->color);
  CERROR_TRY_RETURN(lodepng_color_mode_copy(&dest->color, &source->color));

#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  CERROR_TRY_RETURN(LodePNGText_copy(dest, source));
  CERROR_TRY_RETURN(LodePNGIText_copy(dest, source));
  if(source->iccp_defined) {
    dest->iccp_defined = 0; /*the memcpy above set this to 1 while it shouldn't*/
    CERROR_TRY_RETURN(lodepng_set_icc(dest, source->iccp_name, source->iccp_profile, source->iccp_profile_size));
  }
  if(source->exif_defined) {
    dest->exif_defined = 0; /*the memcpy above set this to 1 while it shouldn't*/
    CERROR_TRY_RETURN(lodepng_set_exif(dest, source->exif, source->exif_size));
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6890
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x5820
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x56a0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x5780
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6981
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a94
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6aa0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x69a2
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a94
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6b50
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x69c3
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a94
movq -0x18(%rbp), %rax
cmpl $0x0, 0xfc(%rax)
je 0x6a1a
movq -0x10(%rbp), %rax
movl $0x0, 0xfc(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x110(%rax), %ecx
callq 0x6290
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x6a18
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a94
jmp 0x6a1a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x6a66
movq -0x10(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x98(%rax), %edx
callq 0x6440
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x6a64
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a94
jmp 0x6a66
movq -0x10(%rbp), %rdi
callq 0x6830
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c40
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x6a8d
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a94
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: LodePNGText_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGText_copy(LodePNGInfo* dest, const LodePNGInfo* source) {
  size_t i = 0;
  dest->text_keys = NULL;
  dest->text_strings = NULL;
  dest->text_num = 0;
  for(i = 0; i != source->text_num; ++i) {
    CERROR_TRY_RETURN(lodepng_add_text(dest, source->text_keys[i], source->text_strings[i]));
  }
  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, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x48(%rcx), %rax
je 0x6b3c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x5d10
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6b2c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6b43
jmp 0x6b2e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6ae4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: LodePNGIText_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGIText_copy(LodePNGInfo* dest, const LodePNGInfo* source) {
  size_t i = 0;
  dest->itext_keys = NULL;
  dest->itext_langtags = NULL;
  dest->itext_transkeys = NULL;
  dest->itext_strings = NULL;
  dest->itext_num = 0;
  for(i = 0; i != source->itext_num; ++i) {
    CERROR_TRY_RETURN(lodepng_add_itext(dest, source->itext_keys[i], source->itext_langtags[i],
                                        source->itext_transkeys[i], source->itext_strings[i]));
  }
  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, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x60(%rcx), %rax
je 0x6c2a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x20(%rbp), %r8
movq (%rax,%r8,8), %r8
callq 0x6040
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6c1a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6c31
jmp 0x6c1c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6baf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng.cpp
// Function: color_tree_add(ColorTree*, unsigned char, unsigned char, unsigned char, unsigned char, unsigned int)
static unsigned color_tree_add(ColorTree* tree,
                               unsigned char r, unsigned char g, unsigned char b, unsigned char a, unsigned index) {
  int bit;
  for(bit = 0; bit < 8; ++bit) {
    int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1);
    if(!tree->children[i]) {
      tree->children[i] = (ColorTree*)lodepng_malloc(sizeof(ColorTree));
      if(!tree->children[i]) return 83; /*alloc fail*/
      color_tree_init(tree->children[i]);
    }
    tree = tree->children[i];
  }
  tree->index = (int)index;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movb %dl, -0x12(%rbp)
movb %cl, -0x13(%rbp)
movb %al, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x743a
movzbl -0x11(%rbp), %eax
movl -0x1c(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
shll $0x3, %eax
movzbl -0x12(%rbp), %edx
movl -0x1c(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x2, %ecx
addl %ecx, %eax
movzbl -0x13(%rbp), %edx
movl -0x1c(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll %ecx
addl %ecx, %eax
movzbl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x741c
movl $0x88, %edi
callq 0x3bc0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x740b
movl $0x53, -0x4(%rbp)
jmp 0x744e
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7320
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7377
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x80(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)