// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: decodeGeneric(unsigned char**, unsigned int*, unsigned int*, LodePNGState*, unsigned char const*, unsigned long)
static void decodeGeneric(unsigned char** out, unsigned* w, unsigned* h,
                          LodePNGState* state,
                          const unsigned char* in, size_t insize)
{
  unsigned char IEND = 0;
  const unsigned char* chunk;
  size_t i;
  ucvector idat; /*the data from idat chunks*/

  /*for unknown chunk order*/
  unsigned unknown = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  unsigned critical_pos = 1; /*1 = after IHDR, 2 = after PLTE, 3 = after IDAT*/
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/

  /*provide some proper output values if error will happen*/
  *out = 0;

  state->error = lodepng_inspect(w, h, state, in, insize); /*reads header and resets other parameters in state->info_png*/
  if(state->error) return;

  ucvector_init(&idat);
  chunk = &in[33]; /*first byte of the first chunk after the header*/

  /*loop through the chunks, ignoring unknown chunks and stopping at IEND chunk.
  IDAT data is put at the start of the in buffer*/
  while(!IEND && !state->error)
  {
    unsigned chunkLength;
    const unsigned char* data; /*the data in the chunk*/

    /*error: size of the in buffer too small to contain next chunk*/
    if((size_t)((chunk - in) + 12) > insize || chunk < in) CERROR_BREAK(state->error, 30);

    /*length of the data of the chunk, excluding the length bytes, chunk type and CRC bytes*/
    chunkLength = lodepng_chunk_length(chunk);
    /*error: chunk length larger than the max PNG chunk size*/
    if(chunkLength > 2147483647) CERROR_BREAK(state->error, 63);

    if((size_t)((chunk - in) + chunkLength + 12) > insize || (chunk + chunkLength + 12) < in)
    {
      CERROR_BREAK(state->error, 64); /*error: size of the in buffer too small to contain next chunk*/
    }

    data = lodepng_chunk_data_const(chunk);

    /*IDAT chunk, containing compressed image data*/
    if(lodepng_chunk_type_equals(chunk, "IDAT"))
    {
      size_t oldsize = idat.size;
      if(!ucvector_resize(&idat, oldsize + chunkLength)) CERROR_BREAK(state->error, 83 /*alloc fail*/);
      for(i = 0; i < chunkLength; i++) idat.data[oldsize + i] = data[i];
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
      critical_pos = 3;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
    }
    /*IEND chunk*/
    else if(lodepng_chunk_type_equals(chunk, "IEND"))
    {
      IEND = 1;
    }
    /*palette chunk (PLTE)*/
    else if(lodepng_chunk_type_equals(chunk, "PLTE"))
    {
      unsigned pos = 0;
      if(state->info_png.color.palette) myfree(state->info_png.color.palette);
      state->info_png.color.palettesize = chunkLength / 3;
      state->info_png.color.palette = (unsigned char*)mymalloc(4 * state->info_png.color.palettesize);
      if(!state->info_png.color.palette && state->info_png.color.palettesize)
      {
        state->info_png.color.palettesize = 0;
        CERROR_BREAK(state->error, 83); /*alloc fail*/
      }
      if(state->info_png.color.palettesize > 256) CERROR_BREAK(state->error, 38); /*error: palette too big*/

      for(i = 0; i < state->info_png.color.palettesize; i++)
      {
        state->info_png.color.palette[4 * i + 0] = data[pos++]; /*R*/
        state->info_png.color.palette[4 * i + 1] = data[pos++]; /*G*/
        state->info_png.color.palette[4 * i + 2] = data[pos++]; /*B*/
        state->info_png.color.palette[4 * i + 3] = 255; /*alpha*/
      }
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
      critical_pos = 2;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
    }
    /*palette transparency chunk (tRNS)*/
    else if(lodepng_chunk_type_equals(chunk, "tRNS"))
    {
      if(state->info_png.color.colortype == LCT_PALETTE)
      {
        /*error: more alpha values given than there are palette entries*/
        if(chunkLength > state->info_png.color.palettesize) CERROR_BREAK(state->error, 38);

        for(i = 0; i < chunkLength; i++) state->info_png.color.palette[4 * i + 3] = data[i];
      }
      else if(state->info_png.color.colortype == LCT_GREY)
      {
        /*error: this chunk must be 2 bytes for greyscale image*/
        if(chunkLength != 2) CERROR_BREAK(state->error, 30);

        state->info_png.color.key_defined = 1;
        state->info_png.color.key_r = state->info_png.color.key_g
                                     = state->info_png.color.key_b = 256 * data[0] + data[1];
      }
      else if(state->info_png.color.colortype == LCT_RGB)
      {
        /*error: this chunk must be 6 bytes for RGB image*/
        if(chunkLength != 6) CERROR_BREAK(state->error, 41);

        state->info_png.color.key_defined = 1;
        state->info_png.color.key_r = 256 * data[0] + data[1];
        state->info_png.color.key_g = 256 * data[2] + data[3];
        state->info_png.color.key_b = 256 * data[4] + data[5];
      }
      else CERROR_BREAK(state->error, 42); /*error: tRNS chunk not allowed for other color models*/
    }
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
    /*background color chunk (bKGD)*/
    else if(lodepng_chunk_type_equals(chunk, "bKGD"))
    {
      if(state->info_png.color.colortype == LCT_PALETTE)
      {
        /*error: this chunk must be 1 byte for indexed color image*/
        if(chunkLength != 1) CERROR_BREAK(state->error, 43);

        state->info_png.background_defined = 1;
        state->info_png.background_r = state->info_png.background_g = state->info_png.background_b = data[0];
      }
      else if(state->info_png.color.colortype == LCT_GREY || state->info_png.color.colortype == LCT_GREY_ALPHA)
      {
        /*error: this chunk must be 2 bytes for greyscale image*/
        if(chunkLength != 2) CERROR_BREAK(state->error, 44);

        state->info_png.background_defined = 1;
        state->info_png.background_r = state->info_png.background_g = state->info_png.background_b
                                     = 256 * data[0] + data[1];
      }
      else if(state->info_png.color.colortype == LCT_RGB || state->info_png.color.colortype == LCT_RGBA)
      {
        /*error: this chunk must be 6 bytes for greyscale image*/
        if(chunkLength != 6) CERROR_BREAK(state->error, 45);

        state->info_png.background_defined = 1;
        state->info_png.background_r = 256 * data[0] + data[1];
        state->info_png.background_g = 256 * data[2] + data[3];
        state->info_png.background_b = 256 * data[4] + data[5];
      }
    }
    /*text chunk (tEXt)*/
    else if(lodepng_chunk_type_equals(chunk, "tEXt"))
    {
      if(state->decoder.read_text_chunks)
      {
        char *key = 0, *str = 0;

        while(!state->error) /*not really a while loop, only used to break on error*/
        {
          unsigned length, string2_begin;

          length = 0;
          while(length < chunkLength && data[length] != 0) length++;
          /*error, end reached, no null terminator?*/
          if(length + 1 >= chunkLength) CERROR_BREAK(state->error, 75);

          key = (char*)mymalloc(length + 1);
          if(!key) CERROR_BREAK(state->error, 83); /*alloc fail*/

          key[length] = 0;
          for(i = 0; i < length; i++) key[i] = data[i];

          string2_begin = length + 1;
          /*error, end reached, no null terminator?*/
          if(string2_begin > chunkLength) CERROR_BREAK(state->error, 75);

          length = chunkLength - string2_begin;
          str = (char*)mymalloc(length + 1);
          if(!str) CERROR_BREAK(state->error, 83); /*alloc fail*/

          str[length] = 0;
          for(i = 0; i < length; i++) str[i] = data[string2_begin + i];

          state->error = lodepng_add_text(&state->info_png, key, str);

          break;
        }

        myfree(key);
        myfree(str);
      }
    }
    /*compressed text chunk (zTXt)*/
    else if(lodepng_chunk_type_equals(chunk, "zTXt"))
    {
      if(state->decoder.read_text_chunks)
      {
        unsigned length, string2_begin;
        char *key = 0;
        ucvector decoded;

        ucvector_init(&decoded);

        while(!state->error) /*not really a while loop, only used to break on error*/
        {
          for(length = 0; length < chunkLength && data[length] != 0; length++) ;
          if(length + 2 >= chunkLength) CERROR_BREAK(state->error, 75); /*no null termination, corrupt?*/

          key = (char*)mymalloc(length + 1);
          if(!key) CERROR_BREAK(state->error, 83); /*alloc fail*/

          key[length] = 0;
          for(i = 0; i < length; i++) key[i] = data[i];

          if(data[length + 1] != 0) CERROR_BREAK(state->error, 72); /*the 0 byte indicating compression must be 0*/

          string2_begin = length + 2;
          if(string2_begin > chunkLength) CERROR_BREAK(state->error, 75); /*no null termination, corrupt?*/

          length = chunkLength - string2_begin;
          state->error = zlib_decompress(&decoded.data, &decoded.size,
                                         (unsigned char*)(&data[string2_begin]),
                                         length, &state->decoder.zlibsettings);
          if(state->error) break;
          ucvector_push_back(&decoded, 0);

          state->error = lodepng_add_text(&state->info_png, key, (char*)decoded.data);

          break;
        }

        myfree(key);
        ucvector_cleanup(&decoded);
        if(state->error) break;
      }
    }
    /*international text chunk (iTXt)*/
    else if(lodepng_chunk_type_equals(chunk, "iTXt"))
    {
      if(state->decoder.read_text_chunks)
      {
        unsigned length, begin, compressed;
        char *key = 0, *langtag = 0, *transkey = 0;
        ucvector decoded;
        ucvector_init(&decoded);

        while(!state->error) /*not really a while loop, only used to break on error*/
        {
          /*Quick check if the chunk length isn't too small. Even without check
          it'd still fail with other error checks below if it's too short. This just gives a different error code.*/
          if(chunkLength < 5) CERROR_BREAK(state->error, 30); /*iTXt chunk too short*/

          /*read the key*/
          for(length = 0; length < chunkLength && data[length] != 0; length++) ;
          if(length + 2 >= chunkLength) CERROR_BREAK(state->error, 75); /*no null termination char found*/

          key = (char*)mymalloc(length + 1);
          if(!key) CERROR_BREAK(state->error, 83); /*alloc fail*/

          key[length] = 0;
          for(i = 0; i < length; i++) key[i] = data[i];

          /*read the compression method*/
          compressed = data[length + 1];
          if(data[length + 2] != 0) CERROR_BREAK(state->error, 72); /*the 0 byte indicating compression must be 0*/

          /*read the langtag*/
          begin = length + 3;
          length = 0;
          for(i = begin; i < chunkLength && data[i] != 0; i++) length++;
          if(begin + length + 1 >= chunkLength) CERROR_BREAK(state->error, 75); /*no null termination char found*/

          langtag = (char*)mymalloc(length + 1);
          if(!langtag) CERROR_BREAK(state->error, 83); /*alloc fail*/

          langtag[length] = 0;
          for(i = 0; i < length; i++) langtag[i] = data[begin + i];

          /*read the transkey*/
          begin += length + 1;
          length = 0;
          for(i = begin; i < chunkLength && data[i] != 0; i++) length++;
          if(begin + length + 1 >= chunkLength) CERROR_BREAK(state->error, 75); /*no null termination, corrupt?*/

          transkey = (char*)mymalloc(length + 1);
          if(!transkey) CERROR_BREAK(state->error, 83); /*alloc fail*/

          transkey[length] = 0;
          for(i = 0; i < length; i++) transkey[i] = data[begin + i];

          /*read the actual text*/
          begin += length + 1;
          if(begin > chunkLength) CERROR_BREAK(state->error, 75); /*no null termination, corrupt?*/

          length = chunkLength - begin;

          if(compressed)
          {
            state->error = zlib_decompress(&decoded.data, &decoded.size,
                                           (unsigned char*)(&data[begin]),
                                           length, &state->decoder.zlibsettings);
            if(state->error) break;
            if(decoded.allocsize < decoded.size) decoded.allocsize = decoded.size;
            ucvector_push_back(&decoded, 0);
          }
          else
          {
            if(!ucvector_resize(&decoded, length + 1)) CERROR_BREAK(state->error, 83 /*alloc fail*/);

            decoded.data[length] = 0;
            for(i = 0; i < length; i++) decoded.data[i] = data[begin + i];
          }

          state->error = lodepng_add_itext(&state->info_png, key, langtag, transkey, (char*)decoded.data);

          break;
        }

        myfree(key);
        myfree(langtag);
        myfree(transkey);
        ucvector_cleanup(&decoded);
        if(state->error) break;
      }
    }
    else if(lodepng_chunk_type_equals(chunk, "tIME"))
    {
      if(chunkLength != 7) CERROR_BREAK(state->error, 73); /*invalid tIME chunk size*/

      state->info_png.time_defined = 1;
      state->info_png.time.year = 256 * data[0] + data[+ 1];
      state->info_png.time.month = data[2];
      state->info_png.time.day = data[3];
      state->info_png.time.hour = data[4];
      state->info_png.time.minute = data[5];
      state->info_png.time.second = data[6];
    }
    else if(lodepng_chunk_type_equals(chunk, "pHYs"))
    {
      if(chunkLength != 9) CERROR_BREAK(state->error, 74); /*invalid pHYs chunk size*/

      state->info_png.phys_defined = 1;
      state->info_png.phys_x = 16777216 * data[0] + 65536 * data[1] + 256 * data[2] + data[3];
      state->info_png.phys_y = 16777216 * data[4] + 65536 * data[5] + 256 * data[6] + data[7];
      state->info_png.phys_unit = data[8];
    }
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
    else /*it's not an implemented chunk type, so ignore it: skip over the data*/
    {
      /*error: unknown critical chunk (5th bit of first byte of chunk type is 0)*/
      if(!lodepng_chunk_ancillary(chunk)) CERROR_BREAK(state->error, 69);

      unknown = 1;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
      if(state->decoder.remember_unknown_chunks)
      {
        state->error = lodepng_chunk_append(&state->info_png.unknown_chunks_data[critical_pos - 1],
                                            &state->info_png.unknown_chunks_size[critical_pos - 1], chunk);
        if(state->error) break;
      }
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
    }

    if(!state->decoder.ignore_crc && !unknown) /*check CRC if wanted, only on known chunk types*/
    {
      if(lodepng_chunk_check_crc(chunk)) CERROR_BREAK(state->error, 57); /*invalid CRC*/
    }

    if(!IEND) chunk = lodepng_chunk_next_const(chunk);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x1, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x7790
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
je 0x7d87
jmp 0x92dd
leaq -0x60(%rbp), %rdi
callq 0xa980
movq -0x28(%rbp), %rax
addq $0x21, %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpb $0x0, -0x31(%rbp)
movb %al, -0x139(%rbp)
jne 0x7dc0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x139(%rbp)
movb -0x139(%rbp), %al
testb $0x1, %al
jne 0x7dcf
jmp 0x916e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0xc, %rax
cmpq -0x30(%rbp), %rax
ja 0x7dee
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7e01
movq -0x20(%rbp), %rax
movl $0x1e, 0x190(%rax)
jmp 0x916e
movq -0x40(%rbp), %rdi
callq 0x4ab0
movl %eax, -0x6c(%rbp)
cmpl $0x7fffffff, -0x6c(%rbp) # imm = 0x7FFFFFFF
jbe 0x7e29
movq -0x20(%rbp), %rax
movl $0x3f, 0x190(%rax)
jmp 0x916e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl -0x6c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
cmpq -0x30(%rbp), %rax
ja 0x7e58
movq -0x40(%rbp), %rax
movl -0x6c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
cmpq -0x28(%rbp), %rax
jae 0x7e6b
movq -0x20(%rbp), %rax
movl $0x40, 0x190(%rax)
jmp 0x916e
movq -0x40(%rbp), %rdi
callq 0x4c40
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x174c6(%rip), %rsi     # 0x1f349
callq 0x4b20
cmpb $0x0, %al
je 0x7f07
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
movl -0x6c(%rbp), %eax
addq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0xd730
cmpl $0x0, %eax
jne 0x7ebf
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x916e
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x6c(%rbp), %ecx
cmpq %rcx, %rax
jae 0x7efb
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x60(%rbp), %rax
movq -0x80(%rbp), %rcx
addq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x7ec7
movl $0x3, -0x68(%rbp)
jmp 0x9126
movq -0x40(%rbp), %rdi
leaq 0x1743c(%rip), %rsi     # 0x1f34e
callq 0x4b20
cmpb $0x0, %al
je 0x7f24
movb $0x1, -0x31(%rbp)
jmp 0x9124
movq -0x40(%rbp), %rdi
leaq 0x17424(%rip), %rsi     # 0x1f353
callq 0x4b20
cmpb $0x0, %al
je 0x80e7
movl $0x0, -0x84(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x7f64
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0x4050
movl -0x6c(%rbp), %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rdi
shlq $0x2, %rdi
callq 0x3840
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
jne 0x7fdf
movq -0x20(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x7fdf
movq -0x20(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
cmpq $0x100, 0xc8(%rax) # imm = 0x100
jbe 0x8003
movq -0x20(%rbp), %rax
movl $0x26, 0x190(%rax)
jmp 0x916e
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0xc8(%rcx), %rax
jae 0x80db
movq -0x78(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x84(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x2, %rcx
movb %dl, (%rax,%rcx)
movq -0x78(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x84(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x2, %rcx
movb %dl, 0x1(%rax,%rcx)
movq -0x78(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x84(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x2, %rcx
movb %dl, 0x2(%rax,%rcx)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x2, %rcx
movb $-0x1, 0x3(%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x800b
movl $0x2, -0x68(%rbp)
jmp 0x9122
movq -0x40(%rbp), %rdi
leaq 0x17266(%rip), %rsi     # 0x1f358
callq 0x4b20
cmpb $0x0, %al
je 0x8295
movq -0x20(%rbp), %rax
cmpl $0x3, 0xb8(%rax)
jne 0x8178
movl -0x6c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpq 0xc8(%rcx), %rax
jbe 0x812f
movq -0x20(%rbp), %rax
movl $0x26, 0x190(%rax)
jmp 0x916e
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x6c(%rbp), %ecx
cmpq %rcx, %rax
jae 0x8173
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x2, %rcx
movb %dl, 0x3(%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8137
jmp 0x8290
movq -0x20(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
jne 0x81e3
cmpl $0x2, -0x6c(%rbp)
je 0x819e
movq -0x20(%rbp), %rax
movl $0x1e, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
movl $0x1, 0xd0(%rax)
movq -0x78(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xdc(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0xd8(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0xd4(%rax)
jmp 0x828e
movq -0x20(%rbp), %rax
cmpl $0x2, 0xb8(%rax)
jne 0x8279
cmpl $0x6, -0x6c(%rbp)
je 0x820d
movq -0x20(%rbp), %rax
movl $0x29, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
movl $0x1, 0xd0(%rax)
movq -0x78(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xd4(%rax)
movq -0x78(%rbp), %rax
movzbl 0x2(%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xd8(%rax)
movq -0x78(%rbp), %rax
movzbl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x5(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xdc(%rax)
jmp 0x828c
movq -0x20(%rbp), %rax
movl $0x2a, 0x190(%rax)
jmp 0x916e
jmp 0x828e
jmp 0x8290
jmp 0x9120
movq -0x40(%rbp), %rdi
leaq 0x170bd(%rip), %rsi     # 0x1f35d
callq 0x4b20
cmpb $0x0, %al
je 0x842d
movq -0x20(%rbp), %rax
cmpl $0x3, 0xb8(%rax)
jne 0x830b
cmpl $0x1, -0x6c(%rbp)
je 0x82d3
movq -0x20(%rbp), %rax
movl $0x2b, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x78(%rbp), %rax
movzbl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xec(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0xe4(%rax)
jmp 0x8428
movq -0x20(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
je 0x8325
movq -0x20(%rbp), %rax
cmpl $0x4, 0xb8(%rax)
jne 0x8383
cmpl $0x2, -0x6c(%rbp)
je 0x833e
movq -0x20(%rbp), %rax
movl $0x2c, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x78(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xec(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0xe4(%rax)
jmp 0x8426
movq -0x20(%rbp), %rax
cmpl $0x2, 0xb8(%rax)
je 0x83a1
movq -0x20(%rbp), %rax
cmpl $0x6, 0xb8(%rax)
jne 0x8424
cmpl $0x6, -0x6c(%rbp)
je 0x83ba
movq -0x20(%rbp), %rax
movl $0x2d, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x78(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x78(%rbp), %rax
movzbl 0x2(%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq -0x78(%rbp), %rax
movzbl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x5(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xec(%rax)
jmp 0x8426
jmp 0x8428
jmp 0x911e
movq -0x40(%rbp), %rdi
leaq 0x16f2a(%rip), %rsi     # 0x1f362
callq 0x4b20
cmpb $0x0, %al
je 0x8687
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x8682
movq $0x0, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8482
jmp 0x866a
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x6c(%rbp), %ecx
movb %al, -0x13a(%rbp)
jae 0x84b9
movq -0x78(%rbp), %rax
movl -0x9c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x13a(%rbp)
movb -0x13a(%rbp), %al
testb $0x1, %al
jne 0x84c5
jmp 0x84d6
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x848c
movl -0x9c(%rbp), %eax
addl $0x1, %eax
cmpl -0x6c(%rbp), %eax
jb 0x84f7
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x866a
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3840
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
jne 0x852d
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x866a
movq -0x90(%rbp), %rax
movl -0x9c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x9c(%rbp), %ecx
cmpq %rcx, %rax
jae 0x857c
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x90(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8546
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jbe 0x85a9
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x866a
movl -0x6c(%rbp), %eax
subl -0xa0(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3840
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x85eb
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x866a
movq -0x98(%rbp), %rax
movl -0x9c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x9c(%rbp), %ecx
cmpq %rcx, %rax
jae 0x8640
movq -0x78(%rbp), %rax
movl -0xa0(%rbp), %ecx
addq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8604
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x5640
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0x90(%rbp), %rdi
callq 0x4050
movq -0x98(%rbp), %rdi
callq 0x4050
jmp 0x911c
movq -0x40(%rbp), %rdi
leaq 0x16cd5(%rip), %rsi     # 0x1f367
callq 0x4b20
cmpb $0x0, %al
je 0x88f8
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x88f3
movq $0x0, -0xb0(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xa980
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x86dd
jmp 0x88c7
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %ecx
xorl %eax, %eax
cmpl -0x6c(%rbp), %ecx
movb %al, -0x13b(%rbp)
jae 0x8714
movq -0x78(%rbp), %rax
movl -0xa4(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x13b(%rbp)
movb -0x13b(%rbp), %al
testb $0x1, %al
jne 0x8720
jmp 0x8733
jmp 0x8722
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x86e7
movl -0xa4(%rbp), %eax
addl $0x2, %eax
cmpl -0x6c(%rbp), %eax
jb 0x8754
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x88c7
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3840
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0x878a
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x88c7
movq -0xb0(%rbp), %rax
movl -0xa4(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0xa4(%rbp), %ecx
cmpq %rcx, %rax
jae 0x87d9
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0xb0(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x87a3
movq -0x78(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x8804
movq -0x20(%rbp), %rax
movl $0x48, 0x190(%rax)
jmp 0x88c7
movl -0xa4(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xa8(%rbp)
movl -0xa8(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jbe 0x8831
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x88c7
movl -0x6c(%rbp), %eax
subl -0xa8(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
addq $0x8, %rsi
movq -0x78(%rbp), %rdx
movl -0xa8(%rbp), %eax
addq %rax, %rdx
movl -0xa4(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %r8
addq $0x8, %r8
callq 0xc2c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
je 0x888f
jmp 0x88c7
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
callq 0x4840
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movq -0xb0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x5640
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0xb0(%rbp), %rdi
callq 0x4050
leaq -0xc8(%rbp), %rdi
callq 0x10950
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
je 0x88f1
jmp 0x916e
jmp 0x88f3
jmp 0x911a
movq -0x40(%rbp), %rdi
leaq 0x16a69(%rip), %rsi     # 0x1f36c
callq 0x4b20
cmpb $0x0, %al
je 0x8ef6
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x8ef1
movq $0x0, -0xe0(%rbp)
movq $0x0, -0xe8(%rbp)
movq $0x0, -0xf0(%rbp)
leaq -0x108(%rbp), %rdi
callq 0xa980
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8964
jmp 0x8ead
cmpl $0x5, -0x6c(%rbp)
jae 0x897d
movq -0x20(%rbp), %rax
movl $0x1e, 0x190(%rax)
jmp 0x8ead
movl $0x0, -0xcc(%rbp)
movl -0xcc(%rbp), %ecx
xorl %eax, %eax
cmpl -0x6c(%rbp), %ecx
movb %al, -0x13c(%rbp)
jae 0x89b4
movq -0x78(%rbp), %rax
movl -0xcc(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x13c(%rbp)
movb -0x13c(%rbp), %al
testb $0x1, %al
jne 0x89c0
jmp 0x89d3
jmp 0x89c2
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x8987
movl -0xcc(%rbp), %eax
addl $0x2, %eax
cmpl -0x6c(%rbp), %eax
jb 0x89f4
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x8ead
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3840
movq %rax, -0xe0(%rbp)
cmpq $0x0, -0xe0(%rbp)
jne 0x8a2a
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x8ead
movq -0xe0(%rbp), %rax
movl -0xcc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0xcc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x8a79
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0xe0(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8a43
movq -0x78(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0xd4(%rbp)
movq -0x78(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x8abd
movq -0x20(%rbp), %rax
movl $0x48, 0x190(%rax)
jmp 0x8ead
movl -0xcc(%rbp), %eax
addl $0x3, %eax
movl %eax, -0xd0(%rbp)
movl $0x0, -0xcc(%rbp)
movl -0xd0(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movl -0x6c(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x13d(%rbp)
jae 0x8b0e
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x13d(%rbp)
movb -0x13d(%rbp), %al
testb $0x1, %al
jne 0x8b1a
jmp 0x8b37
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8ae0
movl -0xd0(%rbp), %eax
addl -0xcc(%rbp), %eax
addl $0x1, %eax
cmpl -0x6c(%rbp), %eax
jb 0x8b5e
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x8ead
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3840
movq %rax, -0xe8(%rbp)
cmpq $0x0, -0xe8(%rbp)
jne 0x8b94
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x8ead
movq -0xe8(%rbp), %rax
movl -0xcc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0xcc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x8be9
movq -0x78(%rbp), %rax
movl -0xd0(%rbp), %ecx
addq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0xe8(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8bad
movl -0xcc(%rbp), %eax
addl $0x1, %eax
addl -0xd0(%rbp), %eax
movl %eax, -0xd0(%rbp)
movl $0x0, -0xcc(%rbp)
movl -0xd0(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movl -0x6c(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x13e(%rbp)
jae 0x8c40
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x13e(%rbp)
movb -0x13e(%rbp), %al
testb $0x1, %al
jne 0x8c4c
jmp 0x8c69
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8c12
movl -0xd0(%rbp), %eax
addl -0xcc(%rbp), %eax
addl $0x1, %eax
cmpl -0x6c(%rbp), %eax
jb 0x8c90
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x8ead
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3840
movq %rax, -0xf0(%rbp)
cmpq $0x0, -0xf0(%rbp)
jne 0x8cc6
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x8ead
movq -0xf0(%rbp), %rax
movl -0xcc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0xcc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x8d1b
movq -0x78(%rbp), %rax
movl -0xd0(%rbp), %ecx
addq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0xf0(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8cdf
movl -0xcc(%rbp), %eax
addl $0x1, %eax
addl -0xd0(%rbp), %eax
movl %eax, -0xd0(%rbp)
movl -0xd0(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jbe 0x8d4e
movq -0x20(%rbp), %rax
movl $0x4b, 0x190(%rax)
jmp 0x8ead
movl -0x6c(%rbp), %eax
subl -0xd0(%rbp), %eax
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xd4(%rbp)
je 0x8ded
leaq -0x108(%rbp), %rdi
leaq -0x108(%rbp), %rsi
addq $0x8, %rsi
movq -0x78(%rbp), %rdx
movl -0xd0(%rbp), %eax
addq %rax, %rdx
movl -0xcc(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %r8
addq $0x8, %r8
callq 0xc2c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
je 0x8dbc
jmp 0x8ead
movq -0xf8(%rbp), %rax
cmpq -0x100(%rbp), %rax
jae 0x8dda
movq -0x100(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x108(%rbp), %rdi
xorl %esi, %esi
callq 0x4840
jmp 0x8e75
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x108(%rbp), %rdi
callq 0xd730
cmpl $0x0, %eax
jne 0x8e1e
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
jmp 0x8ead
movq -0x108(%rbp), %rax
movl -0xcc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0xcc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x8e73
movq -0x78(%rbp), %rax
movl -0xd0(%rbp), %ecx
addq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x108(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x8e37
jmp 0x8e75
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movq -0xe0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movq -0xf0(%rbp), %rcx
movq -0x108(%rbp), %r8
callq 0x5930
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0xe0(%rbp), %rdi
callq 0x4050
movq -0xe8(%rbp), %rdi
callq 0x4050
movq -0xf0(%rbp), %rdi
callq 0x4050
leaq -0x108(%rbp), %rdi
callq 0x10950
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
je 0x8eef
jmp 0x916e
jmp 0x8ef1
jmp 0x9118
movq -0x40(%rbp), %rdi
leaq 0x16470(%rip), %rsi     # 0x1f371
callq 0x4b20
cmpb $0x0, %al
je 0x8fb2
cmpl $0x7, -0x6c(%rbp)
je 0x8f27
movq -0x20(%rbp), %rax
movl $0x49, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
movl $0x1, 0x130(%rax)
movq -0x78(%rbp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x78(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x134(%rax)
movq -0x78(%rbp), %rax
movzbl 0x2(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x138(%rax)
movq -0x78(%rbp), %rax
movzbl 0x3(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x13c(%rax)
movq -0x78(%rbp), %rax
movzbl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x140(%rax)
movq -0x78(%rbp), %rax
movzbl 0x5(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x144(%rax)
movq -0x78(%rbp), %rax
movzbl 0x6(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x148(%rax)
jmp 0x9116
movq -0x40(%rbp), %rdi
leaq 0x163b9(%rip), %rsi     # 0x1f376
callq 0x4b20
cmpb $0x0, %al
je 0x9079
cmpl $0x9, -0x6c(%rbp)
je 0x8fe3
movq -0x20(%rbp), %rax
movl $0x4a, 0x190(%rax)
jmp 0x916e
movq -0x20(%rbp), %rax
movl $0x1, 0x14c(%rax)
movq -0x78(%rbp), %rax
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x78(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x78(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x78(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x150(%rax)
movq -0x78(%rbp), %rax
movzbl 0x4(%rax), %ecx
shll $0x18, %ecx
movq -0x78(%rbp), %rax
movzbl 0x5(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x78(%rbp), %rax
movzbl 0x6(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x78(%rbp), %rax
movzbl 0x7(%rax), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x154(%rax)
movq -0x78(%rbp), %rax
movzbl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x158(%rax)
jmp 0x9114
movq -0x40(%rbp), %rdi
callq 0x4bc0
cmpb $0x0, %al
jne 0x9099
movq -0x20(%rbp), %rax
movl $0x45, 0x190(%rax)
jmp 0x916e
movl $0x1, -0x64(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x9112
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
addq $0xb8, %rdi
movl -0x68(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0xa8, %rsi
addq $0xd0, %rsi
movl -0x68(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x40(%rbp), %rdx
callq 0x4de0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
je 0x9110
jmp 0x916e
jmp 0x9112
jmp 0x9114
jmp 0x9116
jmp 0x9118
jmp 0x911a
jmp 0x911c
jmp 0x911e
jmp 0x9120
jmp 0x9122
jmp 0x9124
jmp 0x9126
movq -0x20(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x9156
cmpl $0x0, -0x64(%rbp)
jne 0x9156
movq -0x40(%rbp), %rdi
callq 0x4c60
cmpl $0x0, %eax
je 0x9154
movq -0x20(%rbp), %rax
movl $0x39, 0x190(%rax)
jmp 0x916e
jmp 0x9156
cmpb $0x0, -0x31(%rbp)
jne 0x9169
movq -0x40(%rbp), %rdi
callq 0x4db0
movq %rax, -0x40(%rbp)
jmp 0x7d9c
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
jne 0x92d4
leaq -0x120(%rbp), %rdi
callq 0xa980
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
addq $0xa8, %rdx
addq $0x10, %rdx
callq 0x5520
movq %rax, %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addq %rax, %rsi
leaq -0x120(%rbp), %rdi
callq 0xd730
cmpl $0x0, %eax
jne 0x91d6
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
jne 0x9216
leaq -0x120(%rbp), %rdi
leaq -0x120(%rbp), %rsi
addq $0x8, %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x20(%rbp), %r8
addq $0x8, %r8
callq 0xc2c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
jne 0x92c8
leaq -0x138(%rbp), %rdi
callq 0xa980
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
addq $0xa8, %rdx
addq $0x10, %rdx
callq 0x5520
movq %rax, %rsi
leaq -0x138(%rbp), %rdi
xorl %edx, %edx
callq 0x109a0
cmpl $0x0, %eax
jne 0x9277
movq -0x20(%rbp), %rax
movl $0x53, 0x190(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x190(%rax)
jne 0x92ba
movq -0x138(%rbp), %rdi
movq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %r8
addq $0xa8, %r8
callq 0x10a20
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x190(%rax)
movq -0x138(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x120(%rbp), %rdi
callq 0x10950
leaq -0x60(%rbp), %rdi
callq 0x10950
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)