// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: decodeGeneric
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;
  unsigned char* idat; /*the data from idat chunks, zlib compressed*/
  size_t idatsize = 0;
  unsigned char* scanlines = 0;
  size_t scanlines_size = 0, expected_size = 0;
  size_t outsize = 0;

  /*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*/


  /* safe output values in case error happens */
  *out = 0;
  *w = *h = 0;

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

  if(lodepng_pixel_overflow(*w, *h, &state->info_png.color, &state->info_raw)) {
    CERROR_RETURN(state->error, 92); /*overflow possible due to amount of pixels*/
  }

  /*the input filesize is a safe upper bound for the sum of idat chunks size*/
  idat = (unsigned char*)lodepng_malloc(insize);
  if(!idat) CERROR_RETURN(state->error, 83); /*alloc fail*/

  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) {
      if(state->decoder.ignore_end) break; /*other errors may still happen though*/
      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) {
      if(state->decoder.ignore_end) break; /*other errors may still happen though*/
      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);

    unknown = 0;

    /*IDAT chunk, containing compressed image data*/
    if(lodepng_chunk_type_equals(chunk, "IDAT")) {
      size_t newsize;
      if(lodepng_addofl(idatsize, chunkLength, &newsize)) CERROR_BREAK(state->error, 95);
      if(newsize > insize) CERROR_BREAK(state->error, 95);
      lodepng_memcpy(idat + idatsize, data, chunkLength);
      idatsize += chunkLength;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
      critical_pos = 3;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
    } else if(lodepng_chunk_type_equals(chunk, "IEND")) {
      /*IEND chunk*/
      IEND = 1;
    } else if(lodepng_chunk_type_equals(chunk, "PLTE")) {
      /*palette chunk (PLTE)*/
      state->error = readChunk_PLTE(&state->info_png.color, data, chunkLength);
      if(state->error) break;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
      critical_pos = 2;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
    } else if(lodepng_chunk_type_equals(chunk, "tRNS")) {
      /*palette transparency chunk (tRNS). Even though this one is an ancillary chunk , it is still compiled
      in without 'LODEPNG_COMPILE_ANCILLARY_CHUNKS' because it contains essential color information that
      affects the alpha channel of pixels. */
      state->error = readChunk_tRNS(&state->info_png.color, data, chunkLength);
      if(state->error) break;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
      /*background color chunk (bKGD)*/
    } else if(lodepng_chunk_type_equals(chunk, "bKGD")) {
      state->error = readChunk_bKGD(&state->info_png, data, chunkLength);
      if(state->error) break;
    } else if(lodepng_chunk_type_equals(chunk, "tEXt")) {
      /*text chunk (tEXt)*/
      if(state->decoder.read_text_chunks) {
        state->error = readChunk_tEXt(&state->info_png, data, chunkLength);
        if(state->error) break;
      }
    } else if(lodepng_chunk_type_equals(chunk, "zTXt")) {
      /*compressed text chunk (zTXt)*/
      if(state->decoder.read_text_chunks) {
        state->error = readChunk_zTXt(&state->info_png, &state->decoder.zlibsettings, data, chunkLength);
        if(state->error) break;
      }
    } else if(lodepng_chunk_type_equals(chunk, "iTXt")) {
      /*international text chunk (iTXt)*/
      if(state->decoder.read_text_chunks) {
        state->error = readChunk_iTXt(&state->info_png, &state->decoder.zlibsettings, data, chunkLength);
        if(state->error) break;
      }
    } else if(lodepng_chunk_type_equals(chunk, "tIME")) {
      state->error = readChunk_tIME(&state->info_png, data, chunkLength);
      if(state->error) break;
    } else if(lodepng_chunk_type_equals(chunk, "pHYs")) {
      state->error = readChunk_pHYs(&state->info_png, data, chunkLength);
      if(state->error) break;
    } else if(lodepng_chunk_type_equals(chunk, "gAMA")) {
      state->error = readChunk_gAMA(&state->info_png, data, chunkLength);
      if(state->error) break;
    } else if(lodepng_chunk_type_equals(chunk, "cHRM")) {
      state->error = readChunk_cHRM(&state->info_png, data, chunkLength);
      if(state->error) break;
    } else if(lodepng_chunk_type_equals(chunk, "sRGB")) {
      state->error = readChunk_sRGB(&state->info_png, data, chunkLength);
      if(state->error) break;
    } else if(lodepng_chunk_type_equals(chunk, "iCCP")) {
      state->error = readChunk_iCCP(&state->info_png, &state->decoder.zlibsettings, data, chunkLength);
      if(state->error) break;
#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(!state->decoder.ignore_critical && !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, in + insize);
  }

  if(state->info_png.color.colortype == LCT_PALETTE && !state->info_png.color.palette) {
    state->error = 106; /* error: PNG file must have PLTE chunk if color type is palette */
  }

  if(!state->error) {
    /*predict output size, to allocate exact size for output buffer to avoid more dynamic allocation.
    If the decompressed size does not match the prediction, the image must be corrupt.*/
    if(state->info_png.interlace_method == 0) {
      size_t bpp = lodepng_get_bpp(&state->info_png.color);
      expected_size = lodepng_get_raw_size_idat(*w, *h, bpp);
    } else {
      size_t bpp = lodepng_get_bpp(&state->info_png.color);
      /*Adam-7 interlaced: expected size is the sum of the 7 sub-images sizes*/
      expected_size = 0;
      expected_size += lodepng_get_raw_size_idat((*w + 7) >> 3, (*h + 7) >> 3, bpp);
      if(*w > 4) expected_size += lodepng_get_raw_size_idat((*w + 3) >> 3, (*h + 7) >> 3, bpp);
      expected_size += lodepng_get_raw_size_idat((*w + 3) >> 2, (*h + 3) >> 3, bpp);
      if(*w > 2) expected_size += lodepng_get_raw_size_idat((*w + 1) >> 2, (*h + 3) >> 2, bpp);
      expected_size += lodepng_get_raw_size_idat((*w + 1) >> 1, (*h + 1) >> 2, bpp);
      if(*w > 1) expected_size += lodepng_get_raw_size_idat((*w + 0) >> 1, (*h + 1) >> 1, bpp);
      expected_size += lodepng_get_raw_size_idat((*w + 0), (*h + 0) >> 1, bpp);
    }

    state->error = zlib_decompress(&scanlines, &scanlines_size, expected_size, idat, idatsize, &state->decoder.zlibsettings);
  }
  if(!state->error && scanlines_size != expected_size) state->error = 91; /*decompressed size doesn't match prediction*/
  lodepng_free(idat);

  if(!state->error) {
    outsize = lodepng_get_raw_size(*w, *h, &state->info_png.color);
    *out = (unsigned char*)lodepng_malloc(outsize);
    if(!*out) state->error = 83; /*alloc fail*/
  }
  if(!state->error) {
    lodepng_memset(*out, 0, outsize);
    state->error = postProcessScanlines(*out, scanlines, *w, *h, &state->info_png);
  }
  lodepng_free(scanlines);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
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)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movl $0x1, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xaa80
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xc603
jmp 0xd06f
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
addq $0xb8, %rdx
addq $0x10, %rdx
movq -0x20(%rbp), %rcx
addq $0x90, %rcx
callq 0x145b0
cmpl $0x0, %eax
je 0xc646
movq -0x20(%rbp), %rax
movl $0x5c, 0x1f0(%rax)
jmp 0xd06f
movq -0x30(%rbp), %rdi
callq 0x3de0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xc66d
movq -0x20(%rbp), %rax
movl $0x53, 0x1f0(%rax)
jmp 0xd06f
movq -0x28(%rbp), %rax
addq $0x21, %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpb $0x0, -0x31(%rbp)
movb %al, -0xa1(%rbp)
jne 0xc69d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0xc6ac
jmp 0xcd5d
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0xc, %rax
cmpq -0x30(%rbp), %rax
ja 0xc6cb
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xc6ed
movq -0x20(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xc6da
jmp 0xcd5d
movq -0x20(%rbp), %rax
movl $0x1e, 0x1f0(%rax)
jmp 0xcd5d
movq -0x40(%rbp), %rdi
callq 0x5a60
movl %eax, -0x7c(%rbp)
cmpl $0x7fffffff, -0x7c(%rbp) # imm = 0x7FFFFFFF
jbe 0xc724
movq -0x20(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xc711
jmp 0xcd5d
movq -0x20(%rbp), %rax
movl $0x3f, 0x1f0(%rax)
jmp 0xcd5d
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl -0x7c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
cmpq -0x30(%rbp), %rax
ja 0xc753
movq -0x40(%rbp), %rax
movl -0x7c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
cmpq -0x28(%rbp), %rax
jae 0xc766
movq -0x20(%rbp), %rax
movl $0x40, 0x1f0(%rax)
jmp 0xcd5d
movq -0x40(%rbp), %rdi
callq 0x5c70
movq %rax, -0x88(%rbp)
movl $0x0, -0x74(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x1001c(%rip), %rsi     # 0x1c7a4
callq 0x5b10
cmpb $0x0, %al
je 0xc80e
movq -0x50(%rbp), %rdi
movl -0x7c(%rbp), %eax
movl %eax, %esi
leaq -0x90(%rbp), %rdx
callq 0x5e60
cmpl $0x0, %eax
je 0xc7be
movq -0x20(%rbp), %rax
movl $0x5f, 0x1f0(%rax)
jmp 0xcd5d
movq -0x90(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0xc7de
movq -0x20(%rbp), %rax
movl $0x5f, 0x1f0(%rax)
jmp 0xcd5d
movq -0x48(%rbp), %rdi
addq -0x50(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x6440
movl -0x7c(%rbp), %eax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x3, -0x78(%rbp)
jmp 0xcd0d
movq -0x40(%rbp), %rdi
leaq 0xff90(%rip), %rsi      # 0x1c7a9
callq 0x5b10
cmpb $0x0, %al
je 0xc82b
movb $0x1, -0x31(%rbp)
jmp 0xcd0b
movq -0x40(%rbp), %rdi
leaq 0xed57(%rip), %rsi      # 0x1b58d
callq 0x5b10
cmpb $0x0, %al
je 0xc889
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
addq $0x10, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xb240
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xc87d
jmp 0xcd5d
movl $0x2, -0x78(%rbp)
jmp 0xcd09
movq -0x40(%rbp), %rdi
leaq 0xecfe(%rip), %rsi      # 0x1b592
callq 0x5b10
cmpb $0x0, %al
je 0xc8e0
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
addq $0x10, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xb3a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xc8db
jmp 0xcd5d
jmp 0xcd07
movq -0x40(%rbp), %rdi
leaq 0xecac(%rip), %rsi      # 0x1b597
callq 0x5b10
cmpb $0x0, %al
je 0xc933
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xb500
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xc92e
jmp 0xcd5d
jmp 0xcd05
movq -0x40(%rbp), %rdi
leaq 0xec5e(%rip), %rsi      # 0x1b59c
callq 0x5b10
cmpb $0x0, %al
je 0xc992
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0xc98d
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xb670
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xc98b
jmp 0xcd5d
jmp 0xc98d
jmp 0xcd03
movq -0x40(%rbp), %rdi
leaq 0xec04(%rip), %rsi      # 0x1b5a1
callq 0x5b10
cmpb $0x0, %al
je 0xc9f5
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0xc9f0
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x20(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x7c(%rbp), %eax
movl %eax, %ecx
callq 0xb7f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xc9ee
jmp 0xcd5d
jmp 0xc9f0
jmp 0xcd01
movq -0x40(%rbp), %rdi
leaq 0xeba6(%rip), %rsi      # 0x1b5a6
callq 0x5b10
cmpb $0x0, %al
je 0xca58
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0xca53
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x20(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x7c(%rbp), %eax
movl %eax, %ecx
callq 0xb9a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xca51
jmp 0xcd5d
jmp 0xca53
jmp 0xccff
movq -0x40(%rbp), %rdi
leaq 0xeb48(%rip), %rsi      # 0x1b5ab
callq 0x5b10
cmpb $0x0, %al
je 0xcaab
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xbd20
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xcaa6
jmp 0xcd5d
jmp 0xccfd
movq -0x40(%rbp), %rdi
leaq 0xeafa(%rip), %rsi      # 0x1b5b0
callq 0x5b10
cmpb $0x0, %al
je 0xcafe
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xbde0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xcaf9
jmp 0xcd5d
jmp 0xccfb
movq -0x40(%rbp), %rdi
leaq 0xeaac(%rip), %rsi      # 0x1b5b5
callq 0x5b10
cmpb $0x0, %al
je 0xcb51
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xbea0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xcb4c
jmp 0xcd5d
jmp 0xccf9
movq -0x40(%rbp), %rdi
leaq 0xea5e(%rip), %rsi      # 0x1b5ba
callq 0x5b10
cmpb $0x0, %al
je 0xcba4
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xbf20
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xcb9f
jmp 0xcd5d
jmp 0xccf7
movq -0x40(%rbp), %rdi
leaq 0xea10(%rip), %rsi      # 0x1b5bf
callq 0x5b10
cmpb $0x0, %al
je 0xcbf7
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xc130
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xcbf2
jmp 0xcd5d
jmp 0xccf5
movq -0x40(%rbp), %rdi
leaq 0xe9c2(%rip), %rsi      # 0x1b5c4
callq 0x5b10
cmpb $0x0, %al
je 0xcc4e
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
movq -0x20(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x7c(%rbp), %eax
movl %eax, %ecx
callq 0xc180
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xcc49
jmp 0xcd5d
jmp 0xccf3
movq -0x20(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0xcc78
movq -0x40(%rbp), %rdi
callq 0x5bf0
cmpb $0x0, %al
jne 0xcc78
movq -0x20(%rbp), %rax
movl $0x45, 0x1f0(%rax)
jmp 0xcd5d
movl $0x1, -0x74(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0xccf1
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
addq $0x108, %rdi            # imm = 0x108
movl -0x78(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0xb8, %rsi
addq $0x120, %rsi            # imm = 0x120
movl -0x78(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x40(%rbp), %rdx
callq 0x60b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
je 0xccef
jmp 0xcd5d
jmp 0xccf1
jmp 0xccf3
jmp 0xccf5
jmp 0xccf7
jmp 0xccf9
jmp 0xccfb
jmp 0xccfd
jmp 0xccff
jmp 0xcd01
jmp 0xcd03
jmp 0xcd05
jmp 0xcd07
jmp 0xcd09
jmp 0xcd0b
jmp 0xcd0d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xcd3d
cmpl $0x0, -0x74(%rbp)
jne 0xcd3d
movq -0x40(%rbp), %rdi
callq 0x5c90
cmpl $0x0, %eax
je 0xcd3b
movq -0x20(%rbp), %rax
movl $0x39, 0x1f0(%rax)
jmp 0xcd5d
jmp 0xcd3d
cmpb $0x0, -0x31(%rbp)
jne 0xcd58
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x5ea0
movq %rax, -0x40(%rbp)
jmp 0xc679
movq -0x20(%rbp), %rax
cmpl $0x3, 0xc8(%rax)
jne 0xcd86
movq -0x20(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0xcd86
movq -0x20(%rbp), %rax
movl $0x6a, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
jne 0xcf88
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
jne 0xcde4
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
addq $0x10, %rdi
callq 0x6680
movl %eax, %eax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x98(%rbp), %rax
movl %eax, %edx
callq 0x14700
movq %rax, -0x68(%rbp)
jmp 0xcf5f
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
addq $0x10, %rdi
callq 0x6680
movl %eax, %eax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x7, %edi
shrl $0x3, %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x7, %esi
shrl $0x3, %esi
movq -0xa0(%rbp), %rax
movl %eax, %edx
callq 0x14700
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jbe 0xce6e
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x3, %edi
shrl $0x3, %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x7, %esi
shrl $0x3, %esi
movq -0xa0(%rbp), %rax
movl %eax, %edx
callq 0x14700
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x3, %edi
shrl $0x2, %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x3, %esi
shrl $0x3, %esi
movq -0xa0(%rbp), %rax
movl %eax, %edx
callq 0x14700
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jbe 0xced3
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x1, %edi
shrl $0x2, %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x3, %esi
shrl $0x2, %esi
movq -0xa0(%rbp), %rax
movl %eax, %edx
callq 0x14700
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x1, %edi
shrl %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
shrl $0x2, %esi
movq -0xa0(%rbp), %rax
movl %eax, %edx
callq 0x14700
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jbe 0xcf35
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x0, %edi
shrl %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
shrl %esi
movq -0xa0(%rbp), %rax
movl %eax, %edx
callq 0x14700
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x0, %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x0, %esi
shrl %esi
movq -0xa0(%rbp), %rax
movl %eax, %edx
callq 0x14700
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x20(%rbp), %r9
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x144e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
jne 0xcfad
movq -0x60(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0xcfad
movq -0x20(%rbp), %rax
movl $0x5b, 0x1f0(%rax)
movq -0x48(%rbp), %rdi
callq 0x5060
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
jne 0xd014
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
addq $0xb8, %rdx
addq $0x10, %rdx
callq 0x68a0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x3de0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd012
movq -0x20(%rbp), %rax
movl $0x53, 0x1f0(%rax)
jmp 0xd014
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
jne 0xd066
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x70(%rbp), %rdx
xorl %esi, %esi
callq 0x4a10
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x58(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %r8
addq $0xb8, %r8
callq 0x14750
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1f0(%rax)
movq -0x58(%rbp), %rdi
callq 0x5060
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)