// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/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; /*points to beginning of next 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*/
    size_t pos = (size_t)(chunk - in);

    /*error: next chunk out of bounds of the in buffer*/
    if(chunk < in || pos + 12 > insize) {
      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 12 bytes for length, chunk type and CRC*/
    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(pos + (size_t)chunkLength + 12 > insize || pos + (size_t)chunkLength + 12 < pos) {
      CERROR_BREAK(state->error, 64); /*error: size of the in buffer too small to contain next chunk (or int overflow)*/
    }

    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, 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, 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, data, chunkLength);
      if(state->error) break;
    } else if(lodepng_chunk_type_equals(chunk, "sBIT")) {
      state->error = readChunk_sBIT(&state->info_png, 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->error && 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) {
      unsigned bpp = lodepng_get_bpp(&state->info_png.color);
      expected_size = lodepng_get_raw_size_idat(*w, *h, bpp);
    } else {
      unsigned 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 0xfea0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x11e83
jmp 0x12943
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
addq $0xd0, %rdx
addq $0x10, %rdx
movq -0x20(%rbp), %rcx
addq $0xa8, %rcx
callq 0x1aed0
cmpl $0x0, %eax
je 0x11ec6
movq -0x20(%rbp), %rax
movl $0x5c, 0x218(%rax)
jmp 0x12943
movq -0x30(%rbp), %rdi
callq 0x9810
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x11eed
movq -0x20(%rbp), %rax
movl $0x53, 0x218(%rax)
jmp 0x12943
movq -0x28(%rbp), %rax
addq $0x21, %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpb $0x0, -0x31(%rbp)
movb %al, -0xa1(%rbp)
jne 0x11f1d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x11f2c
jmp 0x12642
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x90(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x11f59
movq -0x90(%rbp), %rax
addq $0xc, %rax
cmpq -0x30(%rbp), %rax
jbe 0x11f7b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x11f68
jmp 0x12642
movq -0x20(%rbp), %rax
movl $0x1e, 0x218(%rax)
jmp 0x12642
movq -0x40(%rbp), %rdi
callq 0xae40
movl %eax, -0x7c(%rbp)
cmpl $0x7fffffff, -0x7c(%rbp) # imm = 0x7FFFFFFF
jbe 0x11fb2
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x11f9f
jmp 0x12642
movq -0x20(%rbp), %rax
movl $0x3f, 0x218(%rax)
jmp 0x12642
movq -0x90(%rbp), %rax
movl -0x7c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
cmpq -0x30(%rbp), %rax
ja 0x11fe3
movq -0x90(%rbp), %rax
movl -0x7c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
cmpq -0x90(%rbp), %rax
jae 0x11ff6
movq -0x20(%rbp), %rax
movl $0x40, 0x218(%rax)
jmp 0x12642
movq -0x40(%rbp), %rdi
callq 0xb050
movq %rax, -0x88(%rbp)
movl $0x0, -0x74(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x12165(%rip), %rsi     # 0x2417d
callq 0xaef0
cmpb $0x0, %al
je 0x1209e
movq -0x50(%rbp), %rdi
movl -0x7c(%rbp), %eax
movl %eax, %esi
leaq -0x98(%rbp), %rdx
callq 0xb240
cmpl $0x0, %eax
je 0x1204e
movq -0x20(%rbp), %rax
movl $0x5f, 0x218(%rax)
jmp 0x12642
movq -0x98(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x1206e
movq -0x20(%rbp), %rax
movl $0x5f, 0x218(%rax)
jmp 0x12642
movq -0x48(%rbp), %rdi
addq -0x50(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0xb820
movl -0x7c(%rbp), %eax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x3, -0x78(%rbp)
jmp 0x125f2
movq -0x40(%rbp), %rdi
leaq 0x120d9(%rip), %rsi     # 0x24182
callq 0xaef0
cmpb $0x0, %al
je 0x120bb
movb $0x1, -0x31(%rbp)
jmp 0x125f0
movq -0x40(%rbp), %rdi
leaq 0x10d67(%rip), %rsi     # 0x22e2d
callq 0xaef0
cmpb $0x0, %al
je 0x12119
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
addq $0x10, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x10690
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x1210d
jmp 0x12642
movl $0x2, -0x78(%rbp)
jmp 0x125ee
movq -0x40(%rbp), %rdi
leaq 0x10d0e(%rip), %rsi     # 0x22e32
callq 0xaef0
cmpb $0x0, %al
je 0x12170
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
addq $0x10, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x107f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x1216b
jmp 0x12642
jmp 0x125ec
movq -0x40(%rbp), %rdi
leaq 0x10cbc(%rip), %rsi     # 0x22e37
callq 0xaef0
cmpb $0x0, %al
je 0x121c3
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x10950
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x121be
jmp 0x12642
jmp 0x125ea
movq -0x40(%rbp), %rdi
leaq 0x10c6e(%rip), %rsi     # 0x22e3c
callq 0xaef0
cmpb $0x0, %al
je 0x12222
movq -0x20(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x1221d
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x10ac0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x1221b
jmp 0x12642
jmp 0x1221d
jmp 0x125e8
movq -0x40(%rbp), %rdi
leaq 0x10c14(%rip), %rsi     # 0x22e41
callq 0xaef0
cmpb $0x0, %al
je 0x12285
movq -0x20(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x12280
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x20(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x7c(%rbp), %eax
movl %eax, %ecx
callq 0x10c40
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x1227e
jmp 0x12642
jmp 0x12280
jmp 0x125e6
movq -0x40(%rbp), %rdi
leaq 0x10bb6(%rip), %rsi     # 0x22e46
callq 0xaef0
cmpb $0x0, %al
je 0x122e8
movq -0x20(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x122e3
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x20(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x7c(%rbp), %eax
movl %eax, %ecx
callq 0x10e30
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x122e1
jmp 0x12642
jmp 0x122e3
jmp 0x125e4
movq -0x40(%rbp), %rdi
leaq 0x10b58(%rip), %rsi     # 0x22e4b
callq 0xaef0
cmpb $0x0, %al
je 0x1233b
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x11220
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x12336
jmp 0x12642
jmp 0x125e2
movq -0x40(%rbp), %rdi
leaq 0x10b0a(%rip), %rsi     # 0x22e50
callq 0xaef0
cmpb $0x0, %al
je 0x1238e
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x112e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x12389
jmp 0x12642
jmp 0x125e0
movq -0x40(%rbp), %rdi
leaq 0x10abc(%rip), %rsi     # 0x22e55
callq 0xaef0
cmpb $0x0, %al
je 0x123e1
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x113a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x123dc
jmp 0x12642
jmp 0x125de
movq -0x40(%rbp), %rdi
leaq 0x10a6e(%rip), %rsi     # 0x22e5a
callq 0xaef0
cmpb $0x0, %al
je 0x12434
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x11420
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x1242f
jmp 0x12642
jmp 0x125dc
movq -0x40(%rbp), %rdi
leaq 0x10a20(%rip), %rsi     # 0x22e5f
callq 0xaef0
cmpb $0x0, %al
je 0x12487
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x11630
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x12482
jmp 0x12642
jmp 0x125da
movq -0x40(%rbp), %rdi
leaq 0x109d2(%rip), %rsi     # 0x22e64
callq 0xaef0
cmpb $0x0, %al
je 0x124de
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x20(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x7c(%rbp), %eax
movl %eax, %ecx
callq 0x11680
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x124d9
jmp 0x12642
jmp 0x125d8
movq -0x40(%rbp), %rdi
leaq 0x10980(%rip), %rsi     # 0x22e69
callq 0xaef0
cmpb $0x0, %al
je 0x12531
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x88(%rbp), %rsi
movl -0x7c(%rbp), %eax
movl %eax, %edx
callq 0x118b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x1252c
jmp 0x12642
jmp 0x125d6
movq -0x20(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x1255b
movq -0x40(%rbp), %rdi
callq 0xafd0
cmpb $0x0, %al
jne 0x1255b
movq -0x20(%rbp), %rax
movl $0x45, 0x218(%rax)
jmp 0x12642
movl $0x1, -0x74(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x125d4
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
addq $0x118, %rdi            # imm = 0x118
movl -0x78(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0xd0, %rsi
addq $0x130, %rsi            # imm = 0x130
movl -0x78(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x40(%rbp), %rdx
callq 0xb490
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
je 0x125d2
jmp 0x12642
jmp 0x125d4
jmp 0x125d6
jmp 0x125d8
jmp 0x125da
jmp 0x125dc
jmp 0x125de
jmp 0x125e0
jmp 0x125e2
jmp 0x125e4
jmp 0x125e6
jmp 0x125e8
jmp 0x125ea
jmp 0x125ec
jmp 0x125ee
jmp 0x125f0
jmp 0x125f2
movq -0x20(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x12622
cmpl $0x0, -0x74(%rbp)
jne 0x12622
movq -0x40(%rbp), %rdi
callq 0xb070
cmpl $0x0, %eax
je 0x12620
movq -0x20(%rbp), %rax
movl $0x39, 0x218(%rax)
jmp 0x12642
jmp 0x12622
cmpb $0x0, -0x31(%rbp)
jne 0x1263d
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0xb280
movq %rax, -0x40(%rbp)
jmp 0x11ef9
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
jne 0x12678
movq -0x20(%rbp), %rax
cmpl $0x3, 0xe0(%rax)
jne 0x12678
movq -0x20(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
jne 0x12678
movq -0x20(%rbp), %rax
movl $0x6a, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
jne 0x1285c
movq -0x20(%rbp), %rax
cmpl $0x0, 0xd8(%rax)
jne 0x126d0
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
addq $0x10, %rdi
callq 0xba60
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x9c(%rbp), %edx
callq 0x1b020
movq %rax, -0x68(%rbp)
jmp 0x12833
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
addq $0x10, %rdi
callq 0xba60
movl %eax, -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
movl -0xa0(%rbp), %edx
callq 0x1b020
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jbe 0x12751
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
movl -0xa0(%rbp), %edx
callq 0x1b020
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
movl -0xa0(%rbp), %edx
callq 0x1b020
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jbe 0x127b0
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
movl -0xa0(%rbp), %edx
callq 0x1b020
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
movl -0xa0(%rbp), %edx
callq 0x1b020
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jbe 0x1280c
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x0, %edi
shrl %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
shrl %esi
movl -0xa0(%rbp), %edx
callq 0x1b020
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
movl -0xa0(%rbp), %edx
callq 0x1b020
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 0x1add0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
jne 0x12881
movq -0x60(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x12881
movq -0x20(%rbp), %rax
movl $0x5b, 0x218(%rax)
movq -0x48(%rbp), %rdi
callq 0xa2f0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
jne 0x128e8
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
addq $0xd0, %rdx
addq $0x10, %rdx
callq 0xbc80
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x9810
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x128e6
movq -0x20(%rbp), %rax
movl $0x53, 0x218(%rax)
jmp 0x128e8
movq -0x20(%rbp), %rax
cmpl $0x0, 0x218(%rax)
jne 0x1293a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x70(%rbp), %rdx
xorl %esi, %esi
callq 0x9ca0
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 $0xd0, %r8
callq 0x1b070
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x218(%rax)
movq -0x58(%rbp), %rdi
callq 0xa2f0
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)