// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__tga_load(stbi__context*, int*, int*, int*, int, stbi__result_info*)
static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
   //   read in the TGA header stuff
   int tga_offset = stbi__get8(s);
   int tga_indexed = stbi__get8(s);
   int tga_image_type = stbi__get8(s);
   int tga_is_RLE = 0;
   int tga_palette_start = stbi__get16le(s);
   int tga_palette_len = stbi__get16le(s);
   int tga_palette_bits = stbi__get8(s);
   int tga_x_origin = stbi__get16le(s);
   int tga_y_origin = stbi__get16le(s);
   int tga_width = stbi__get16le(s);
   int tga_height = stbi__get16le(s);
   int tga_bits_per_pixel = stbi__get8(s);
   int tga_comp, tga_rgb16=0;
   int tga_inverted = stbi__get8(s);
   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
   //   image data
   unsigned char *tga_data;
   unsigned char *tga_palette = NULL;
   int i, j;
   unsigned char raw_data[4] = {0};
   int RLE_count = 0;
   int RLE_repeating = 0;
   int read_next_pixel = 1;
   STBI_NOTUSED(ri);

   //   do a tiny bit of precessing
   if ( tga_image_type >= 8 )
   {
      tga_image_type -= 8;
      tga_is_RLE = 1;
   }
   tga_inverted = 1 - ((tga_inverted >> 5) & 1);

   //   If I'm paletted, then I'll use the number of bits from the palette
   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);

   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");

   //   tga info
   *x = tga_width;
   *y = tga_height;
   if (comp) *comp = tga_comp;

   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
      return stbi__errpuc("too large", "Corrupt TGA");

   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");

   // skip to the data's starting position (offset usually = 0)
   stbi__skip(s, tga_offset );

   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
      for (i=0; i < tga_height; ++i) {
         int row = tga_inverted ? tga_height -i - 1 : i;
         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
         stbi__getn(s, tga_row, tga_width * tga_comp);
      }
   } else  {
      //   do I need to load a palette?
      if ( tga_indexed)
      {
         //   any data to skip? (offset usually = 0)
         stbi__skip(s, tga_palette_start );
         //   load the palette
         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
         if (!tga_palette) {
            STBI_FREE(tga_data);
            return stbi__errpuc("outofmem", "Out of memory");
         }
         if (tga_rgb16) {
            stbi_uc *pal_entry = tga_palette;
            STBI_ASSERT(tga_comp == STBI_rgb);
            for (i=0; i < tga_palette_len; ++i) {
               stbi__tga_read_rgb16(s, pal_entry);
               pal_entry += tga_comp;
            }
         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
               STBI_FREE(tga_data);
               STBI_FREE(tga_palette);
               return stbi__errpuc("bad palette", "Corrupt TGA");
         }
      }
      //   load the data
      for (i=0; i < tga_width * tga_height; ++i)
      {
         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
         if ( tga_is_RLE )
         {
            if ( RLE_count == 0 )
            {
               //   yep, get the next byte as a RLE command
               int RLE_cmd = stbi__get8(s);
               RLE_count = 1 + (RLE_cmd & 127);
               RLE_repeating = RLE_cmd >> 7;
               read_next_pixel = 1;
            } else if ( !RLE_repeating )
            {
               read_next_pixel = 1;
            }
         } else
         {
            read_next_pixel = 1;
         }
         //   OK, if I need to read a pixel, do it now
         if ( read_next_pixel )
         {
            //   load however much data we did have
            if ( tga_indexed )
            {
               // read in index, then perform the lookup
               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
               if ( pal_idx >= tga_palette_len ) {
                  // invalid index
                  pal_idx = 0;
               }
               pal_idx *= tga_comp;
               for (j = 0; j < tga_comp; ++j) {
                  raw_data[j] = tga_palette[pal_idx+j];
               }
            } else if(tga_rgb16) {
               STBI_ASSERT(tga_comp == STBI_rgb);
               stbi__tga_read_rgb16(s, raw_data);
            } else {
               //   read in the data raw
               for (j = 0; j < tga_comp; ++j) {
                  raw_data[j] = stbi__get8(s);
               }
            }
            //   clear the reading flag for the next pixel
            read_next_pixel = 0;
         } // end of reading a pixel

         // copy data
         for (j = 0; j < tga_comp; ++j)
           tga_data[i*tga_comp+j] = raw_data[j];

         //   in case we're in RLE mode, keep counting down
         --RLE_count;
      }
      //   do I need to invert the image?
      if ( tga_inverted )
      {
         for (j = 0; j*2 < tga_height; ++j)
         {
            int index1 = j * tga_width * tga_comp;
            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
            for (i = tga_width * tga_comp; i > 0; --i)
            {
               unsigned char temp = tga_data[index1];
               tga_data[index1] = tga_data[index2];
               tga_data[index2] = temp;
               ++index1;
               ++index2;
            }
         }
      }
      //   clear my palette, if I had one
      if ( tga_palette != NULL )
      {
         STBI_FREE( tga_palette );
      }
   }

   // swap RGB - if the source data was RGB16, it already is in the right order
   if (tga_comp >= 3 && !tga_rgb16)
   {
      unsigned char* tga_pixel = tga_data;
      for (i=0; i < tga_width * tga_height; ++i)
      {
         unsigned char temp = tga_pixel[0];
         tga_pixel[0] = tga_pixel[2];
         tga_pixel[2] = temp;
         tga_pixel += tga_comp;
      }
   }

   // convert to target component count
   if (req_comp && req_comp != tga_comp)
      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);

   //   the things I do to get rid of an error message, and yet keep
   //   Microsoft's C compilers happy... [8^(
   tga_palette_start = tga_palette_len = tga_palette_bits =
         tga_x_origin = tga_y_origin = 0;
   //   OK, done
   return tga_data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, 0x28(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdi, %r14
movq 0xb8(%rdi), %rcx
movq 0xc0(%rdi), %rax
cmpq %rax, %rcx
jae 0xd5d1
leaq 0x1(%rcx), %rdx
movq %rdx, 0xb8(%r14)
movb (%rcx), %cl
movl %ecx, 0x20(%rsp)
movq %rdx, %rcx
jmp 0xd631
cmpl $0x0, 0x30(%r14)
je 0xd5fc
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rbx
movl 0x34(%r14), %edx
movq %rbx, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xd606
cltq
addq %rbx, %rax
movb (%rbx), %cl
movl %ecx, 0x20(%rsp)
jmp 0xd61f
movl $0x0, 0x20(%rsp)
jmp 0xd631
movl $0x0, 0x30(%r14)
leaq 0x39(%r14), %rax
movb $0x0, 0x38(%r14)
movl $0x0, 0x20(%rsp)
movq %rax, 0xc0(%r14)
leaq 0x39(%r14), %rcx
movq %rcx, 0xb8(%r14)
cmpq %rax, %rcx
jae 0xd649
leaq 0x1(%rcx), %rdx
movq %rdx, 0xb8(%r14)
movb (%rcx), %sil
movq %rdx, %rcx
jmp 0xd69a
cmpl $0x0, 0x30(%r14)
je 0xd671
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rbx
movl 0x34(%r14), %edx
movq %rbx, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xd675
cltq
addq %rbx, %rax
movb (%rbx), %sil
jmp 0xd688
xorl %esi, %esi
jmp 0xd69a
movl $0x0, 0x30(%r14)
leaq 0x39(%r14), %rax
movb $0x0, 0x38(%r14)
xorl %esi, %esi
movq %rax, 0xc0(%r14)
leaq 0x39(%r14), %rcx
movq %rcx, 0xb8(%r14)
movl %esi, 0xc(%rsp)
cmpq %rax, %rcx
jae 0xd6b6
leaq 0x1(%rcx), %rax
movq %rax, 0xb8(%r14)
movb (%rcx), %al
movl %eax, 0x18(%rsp)
jmp 0xd716
cmpl $0x0, 0x30(%r14)
je 0xd6e1
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rbx
movl 0x34(%r14), %edx
movq %rbx, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xd6eb
cltq
addq %rbx, %rax
movb (%rbx), %cl
movl %ecx, 0x18(%rsp)
jmp 0xd704
movl $0x0, 0x18(%rsp)
jmp 0xd716
movl $0x0, 0x30(%r14)
leaq 0x39(%r14), %rax
movb $0x0, 0x38(%r14)
movl $0x0, 0x18(%rsp)
movq %rax, 0xc0(%r14)
leaq 0x39(%r14), %rax
movq %rax, 0xb8(%r14)
movq %r14, %rdi
callq 0x136e6
movl %eax, %ebx
movq %r14, %rdi
callq 0x136e6
movl %eax, 0x4c(%rsp)
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
movl %ebp, 0x64(%rsp)
movl %ebx, 0x10(%rsp)
jae 0xd754
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movb (%rax), %bpl
jmp 0xd7a5
cmpl $0x0, 0x30(%r14)
je 0xd77c
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rbx
movl 0x34(%r14), %edx
movq %rbx, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xd780
cltq
addq %rbx, %rax
movb (%rbx), %bpl
jmp 0xd793
xorl %ebp, %ebp
jmp 0xd7a5
movl $0x0, 0x30(%r14)
leaq 0x39(%r14), %rax
movb $0x0, 0x38(%r14)
xorl %ebp, %ebp
movq %rax, 0xc0(%r14)
leaq 0x39(%r14), %rax
movq %rax, 0xb8(%r14)
movq %r14, %rdi
callq 0x136e6
movq %r14, %rdi
callq 0x136e6
movq %r14, %rdi
callq 0x136e6
movl %eax, %ebx
movq %r14, %rdi
callq 0x136e6
movl %eax, %esi
movq 0xb8(%r14), %rcx
movq 0xc0(%r14), %rax
cmpq %rax, %rcx
jae 0xd7f2
leaq 0x1(%rcx), %rdx
movq %rdx, 0xb8(%r14)
movb (%rcx), %cl
movl %ecx, 0x14(%rsp)
movq %rdx, %rcx
jmp 0xd864
cmpl $0x0, 0x30(%r14)
je 0xd826
movl %ebp, %r13d
movq %rsi, %rbp
movl %ebx, %r12d
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rbx
movl 0x34(%r14), %edx
movq %rbx, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xd830
cltq
addq %rbx, %rax
movb (%rbx), %cl
movl %ecx, 0x14(%rsp)
jmp 0xd849
movl $0x0, 0x14(%rsp)
jmp 0xd864
movl $0x0, 0x30(%r14)
leaq 0x39(%r14), %rax
movb $0x0, 0x38(%r14)
movl $0x0, 0x14(%rsp)
movq %rax, 0xc0(%r14)
leaq 0x39(%r14), %rcx
movq %rcx, 0xb8(%r14)
movl %r12d, %ebx
movq %rbp, %rsi
movl %r13d, %ebp
cmpq %rax, %rcx
jae 0xd879
leaq 0x1(%rcx), %rax
movq %rax, 0xb8(%r14)
movb (%rcx), %r13b
jmp 0xd8df
cmpl $0x0, 0x30(%r14)
je 0xd8a9
movl %ebp, %r13d
movq %rsi, %rbp
movl %ebx, %r12d
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rbx
movl 0x34(%r14), %edx
movq %rbx, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xd8ae
cltq
addq %rbx, %rax
movb (%rbx), %cl
jmp 0xd8c1
xorl %r13d, %r13d
jmp 0xd8df
movl $0x0, 0x30(%r14)
leaq 0x39(%r14), %rax
movb $0x0, 0x38(%r14)
xorl %ecx, %ecx
movq %rax, 0xc0(%r14)
leaq 0x39(%r14), %rax
movq %rax, 0xb8(%r14)
movl %r12d, %ebx
movq %rbp, %rsi
movl %r13d, %ebp
movl %ecx, %r13d
movl $0x0, 0x1c(%rsp)
cmpb $0x0, 0xc(%rsp)
je 0xd906
movzbl %bpl, %eax
cmpl $0x17, %eax
jg 0xd939
leal -0xf(%rax), %ecx
cmpl $0x2, %ecx
jb 0xd94f
cmpl $0x8, %eax
je 0xd961
jmp 0xd973
movzbl 0x14(%rsp), %eax
cmpl $0xf, %eax
jle 0xd945
cmpl $0x20, %eax
je 0xd97f
cmpl $0x18, %eax
je 0xd97f
cmpl $0x10, %eax
jne 0xd973
movl 0x18(%rsp), %edx
movzbl %dl, %eax
leal -0x8(%rax), %ecx
cmpb $0x8, %dl
cmovbl %eax, %ecx
cmpl $0x3, %ecx
jne 0xd94f
movb $0x2, %bpl
jmp 0xd987
cmpl $0x18, %eax
je 0xd983
cmpl $0x20, %eax
je 0xd983
jmp 0xd973
cmpl $0x8, %eax
je 0xd961
cmpl $0xf, %eax
jne 0xd973
movb $0x3, %bpl
movb $0x1, %al
movl %eax, (%rsp)
movl $0x0, 0x4(%rsp)
jmp 0xd994
movb $0x1, %al
movl %eax, 0x4(%rsp)
movl $0x0, (%rsp)
movb $0x1, %bpl
jmp 0xd994
leaq 0xb8c9(%rip), %rax      # 0x19243
jmp 0xdb0d
movl 0x14(%rsp), %ebp
shrb $0x3, %bpl
movb $0x1, %al
movl %eax, 0x4(%rsp)
movl $0x0, (%rsp)
movzbl %bpl, %r12d
movq 0x40(%rsp), %rax
movl %ebx, (%rax)
movq 0x28(%rsp), %rax
movl %esi, (%rax)
testq %r15, %r15
je 0xd9ae
movl %r12d, (%r15)
movl %ebx, %edi
movl %r12d, %edx
xorl %ecx, %ecx
movq %rsi, %r15
callq 0xfeae
testl %eax, %eax
je 0xda92
movl %ebx, %edi
movq %r15, 0x30(%rsp)
movl %r15d, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0xffc2
testq %rax, %rax
je 0xdb06
movq %rax, 0x38(%rsp)
movl %ebp, 0x60(%rsp)
movl %ebx, 0x8(%rsp)
movzbl 0x20(%rsp), %esi
shrb $0x5, %r13b
movl %r13d, 0x48(%rsp)
movl 0xc(%rsp), %r13d
testb %r13b, %r13b
setne %bl
cmpb $0x8, 0x18(%rsp)
setae %r15b
movq %r14, %rdi
callq 0xfe58
orb %bl, %r15b
orb (%rsp), %r15b
movl %r12d, 0x28(%rsp)
je 0xda9b
testb %r13b, %r13b
je 0xdaee
movq %r14, %rdi
movl 0x10(%rsp), %esi
callq 0xfe58
movl 0x4c(%rsp), %r15d
movl %r15d, %edi
movl %r12d, %esi
xorl %edx, %edx
callq 0xff0b
testq %rax, %rax
movl 0x8(%rsp), %ebx
je 0xdafc
movq %rax, %r13
cmpb $0x0, 0x4(%rsp)
je 0xdb25
imull %r12d, %r15d
movq %r14, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x126e2
testl %eax, %eax
movl 0xc(%rsp), %r12d
je 0xdfe8
movq %r13, 0x50(%rsp)
jmp 0xdbbf
leaq 0xb106(%rip), %rax      # 0x18b9f
jmp 0xdb0d
cmpl $0x0, 0x30(%rsp)
movl 0x48(%rsp), %r13d
movq 0x38(%rsp), %r12
je 0xdf73
movl 0x8(%rsp), %ebp
imull 0x28(%rsp), %ebp
movq 0x30(%rsp), %rax
leal -0x1(%rax), %ebx
xorl %r15d, %r15d
testb $0x1, %r13b
movl %r15d, %eax
cmovel %ebx, %eax
imull %ebp, %eax
movslq %eax, %rsi
addq %r12, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x126e2
incl %r15d
addl $-0x1, %ebx
jb 0xdac4
jmp 0xdf73
movq $0x0, 0x50(%rsp)
jmp 0xdbb6
movq 0x38(%rsp), %rdi
callq 0x21d0
leaq 0xb09c(%rip), %rax      # 0x18ba9
movq %rax, 0xf6e4(%rip)      # 0x1d1f8
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, %r12d
movl 0xc(%rsp), %r12d
jne 0xe025
testl %r15d, %r15d
movq %r13, 0x50(%rsp)
je 0xdbbb
movl %r15d, %eax
leaq (%rax,%rax,2), %rbx
xorl %r15d, %r15d
movl $0xffff, %ebp           # imm = 0xFFFF
movq %r14, %rdi
callq 0x136e6
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %ecx, %edx
andl %ebp, %edx
imull $0x2109, %edx, %ecx     # imm = 0x2109
shrl $0x12, %ecx
movb %cl, (%r13,%r15)
movl %eax, %ecx
shrl $0x5, %ecx
andl $0x1f, %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %ecx, %edx
andl %ebp, %edx
imull $0x2109, %edx, %ecx     # imm = 0x2109
shrl $0x12, %ecx
movb %cl, 0x1(%r13,%r15)
andl $0x1f, %eax
movl %eax, %ecx
shll $0x8, %ecx
subl %eax, %ecx
andl %ebp, %ecx
imull $0x2109, %ecx, %eax     # imm = 0x2109
shrl $0x12, %eax
movb %al, 0x2(%r13,%r15)
addq $0x3, %r15
cmpl %r15d, %ebx
jne 0xdb4d
movl 0xc(%rsp), %r12d
movl 0x8(%rsp), %ebx
movq 0x30(%rsp), %rax
imull %ebx, %eax
testl %eax, %eax
je 0xdeed
leaq 0x38(%r14), %rcx
movq %rcx, 0x40(%rsp)
leaq 0x39(%r14), %rcx
movq %rcx, 0x20(%rsp)
movl 0x28(%rsp), %r15d
movl %eax, %ebp
movb $0x1, %al
xorl %ebx, %ebx
movl $0x0, 0x10(%rsp)
xorl %r13d, %r13d
movq %rbp, 0x58(%rsp)
cmpb $0x8, 0x18(%rsp)
jb 0xdcc6
testl %r13d, %r13d
je 0xdc3a
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rsp)
setne %dl
sete %sil
orb %al, %sil
movl $0x1, 0x10(%rsp)
testb $0x1, %sil
je 0xdda7
movb %dl, %cl
movl %ecx, 0x10(%rsp)
jmp 0xdcc6
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
jae 0xdc59
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movb (%rax), %al
jmp 0xdcb2
cmpl $0x0, 0x30(%r14)
je 0xdc89
movq 0x28(%r14), %rdi
movl 0x34(%r14), %edx
movq 0x40(%rsp), %r13
movq %r13, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xdc8d
movslq %eax, %rcx
addq %r13, %rcx
movb (%r13), %al
movq 0x20(%rsp), %rdx
jmp 0xdca4
xorl %eax, %eax
jmp 0xdcb2
movl $0x0, 0x30(%r14)
movb $0x0, 0x38(%r14)
xorl %eax, %eax
movq 0x20(%rsp), %rdx
movq %rdx, %rcx
movq %rcx, 0xc0(%r14)
movq %rdx, 0xb8(%r14)
movzbl %al, %eax
movl %eax, %r13d
andl $0x7f, %r13d
incl %r13d
shrl $0x7, %eax
movl %eax, 0x10(%rsp)
testb %r12b, %r12b
je 0xdcfc
cmpb $0x8, 0x14(%rsp)
jne 0xddb7
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
jae 0xde38
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movb (%rax), %al
jmp 0xde95
cmpb $0x0, 0x4(%rsp)
je 0xddc6
cmpl $0x0, 0x28(%rsp)
je 0xdedc
movq 0xb8(%r14), %rcx
movq 0xc0(%r14), %rax
xorl %ebp, %ebp
cmpq %rax, %rcx
jae 0xdd39
leaq 0x1(%rcx), %rsi
movq %rsi, 0xb8(%r14)
movb (%rcx), %dl
movq %rsi, %rcx
jmp 0xdd91
cmpl $0x0, 0x30(%r14)
je 0xdd68
movq 0x28(%r14), %rdi
movl 0x34(%r14), %edx
movq 0x40(%rsp), %r12
movq %r12, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xdd6c
cltq
addq %r12, %rax
movb (%r12), %dl
movq 0x20(%rsp), %rcx
jmp 0xdd83
xorl %edx, %edx
jmp 0xdd91
movl $0x0, 0x30(%r14)
movb $0x0, 0x38(%r14)
xorl %edx, %edx
movq 0x20(%rsp), %rcx
movq %rcx, %rax
movq %rax, 0xc0(%r14)
movq %rcx, 0xb8(%r14)
movb %dl, 0x1c(%rsp,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0xdd22
movl 0xc(%rsp), %r12d
movq 0x58(%rsp), %rbp
cmpl $0x0, 0x28(%rsp)
jne 0xdec1
jmp 0xdedc
movq %r14, %rdi
callq 0x136e6
movl %eax, %esi
jmp 0xde98
cmpl $0x3, 0x28(%rsp)
jne 0xe006
movq %r14, %rdi
callq 0x136e6
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %ecx, %edx
movl $0xffff, %esi           # imm = 0xFFFF
andl %esi, %edx
imull $0x2109, %edx, %ecx     # imm = 0x2109
shrl $0x12, %ecx
movb %cl, 0x1c(%rsp)
movl %eax, %ecx
shrl $0x5, %ecx
andl $0x1f, %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %ecx, %edx
andl %esi, %edx
imull $0x2109, %edx, %ecx     # imm = 0x2109
shrl $0x12, %ecx
movb %cl, 0x1d(%rsp)
andl $0x1f, %eax
movl %eax, %ecx
shll $0x8, %ecx
subl %eax, %ecx
andl %esi, %ecx
imull $0x2109, %ecx, %eax     # imm = 0x2109
shrl $0x12, %eax
movb %al, 0x1e(%rsp)
jmp 0xdec1
cmpl $0x0, 0x30(%r14)
je 0xde67
movq 0x28(%r14), %rdi
movl 0x34(%r14), %edx
movq 0x40(%rsp), %rbp
movq %rbp, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0xde6b
movslq %eax, %rcx
addq %rbp, %rcx
movb (%rbp), %al
movq 0x20(%rsp), %rdx
jmp 0xde82
xorl %eax, %eax
jmp 0xde95
movl $0x0, 0x30(%r14)
movb $0x0, 0x38(%r14)
xorl %eax, %eax
movq 0x20(%rsp), %rdx
movq %rdx, %rcx
movq 0x58(%rsp), %rbp
movq %rcx, 0xc0(%r14)
movq %rdx, 0xb8(%r14)
movzbl %al, %esi
movl 0x28(%rsp), %eax
testl %eax, %eax
je 0xdedc
cmpl 0x4c(%rsp), %esi
movl $0x0, %ecx
cmovael %ecx, %esi
imull %eax, %esi
addq 0x50(%rsp), %rsi
leaq 0x1c(%rsp), %rdi
movq %r15, %rdx
callq 0x2140
movl 0x28(%rsp), %eax
movl %eax, %edi
imull %ebx, %edi
addq 0x38(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
movq %r15, %rdx
callq 0x2140
decl %r13d
incq %rbx
xorl %eax, %eax
cmpq %rbp, %rbx
jne 0xdbfc
cmpl $0x0, 0x30(%rsp)
sete %al
movl 0x48(%rsp), %ecx
orb %al, %cl
testb $0x1, %cl
movq 0x38(%rsp), %r12
movl 0x28(%rsp), %ecx
movq 0x50(%rsp), %rdi
jne 0xdf69
movl 0x8(%rsp), %eax
imull %ecx, %eax
movq 0x30(%rsp), %rcx
decl %ecx
movl %eax, %edx
imull %ecx, %edx
shrl %ecx
leal 0x1(%rax), %esi
xorl %r15d, %r15d
xorl %r8d, %r8d
movl %r15d, %r15d
testl %eax, %eax
je 0xdf58
movslq %edx, %r9
movl %esi, %r10d
movq %r12, %r11
movb (%r11,%r15), %bl
movb (%r11,%r9), %bpl
movb %bpl, (%r11,%r15)
movb %bl, (%r11,%r9)
incq %r11
decl %r10d
cmpl $0x1, %r10d
jg 0xdf3c
leal 0x1(%r8), %r9d
subl %eax, %edx
addl %eax, %r15d
cmpl %ecx, %r8d
movl %r9d, %r8d
jne 0xdf2c
testq %rdi, %rdi
je 0xdf73
callq 0x21d0
cmpb $0x3, 0x60(%rsp)
setb %al
movl (%rsp), %ecx
orb %al, %cl
movl 0x8(%rsp), %ecx
movq %r12, %rax
movl 0x28(%rsp), %esi
movq 0x30(%rsp), %r8
jne 0xdfbe
movl %r8d, %r9d
imull %ecx, %r9d
testl %r9d, %r9d
je 0xdfbe
movl %esi, %r11d
movq %rax, %rdx
addq $0x2, %rdx
movb -0x2(%rdx), %r10b
movb (%rdx), %dil
movb %dil, -0x2(%rdx)
movb %r10b, (%rdx)
addq %r11, %rdx
decl %r9d
jne 0xdfa8
movl 0x64(%rsp), %edx
testl %edx, %edx
je 0xdb16
cmpl %edx, %esi
je 0xdb16
movq %rax, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11e4d
movq 0x38(%rsp), %rdi
callq 0x21d0
movq %r13, %rdi
callq 0x21d0
leaq 0xb347(%rip), %rax      # 0x19348
jmp 0xdb0d
leaq 0xb2d1(%rip), %rdi      # 0x192de
leaq 0xaa22(%rip), %rsi      # 0x18a36
leaq 0xb2d8(%rip), %rcx      # 0x192f3
movl $0x1611, %edx           # imm = 0x1611
callq 0x20f0
leaq 0xb2b2(%rip), %rdi      # 0x192de
leaq 0xaa03(%rip), %rsi      # 0x18a36
leaq 0xb2b9(%rip), %rcx      # 0x192f3
movl $0x15e0, %edx           # imm = 0x15E0
callq 0x20f0