// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movl %eax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x68(%rbp)
movl $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x74(%rbp)
movq $0x0, -0x88(%rbp)
leaq -0x94(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x2100
movl $0x0, -0x98(%rbp)
movl $0x0, -0x9c(%rbp)
movl $0x1, -0xa0(%rbp)
cmpl $0x8, -0x44(%rbp)
jl 0xb3e5
movl -0x44(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x44(%rbp)
movl $0x1, -0x48(%rbp)
movl -0x74(%rbp), %ecx
sarl $0x5, %ecx
andl $0x1, %ecx
movl $0x1, %eax
subl %ecx, %eax
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0xb411
movl -0x54(%rbp), %edi
xorl %esi, %esi
leaq -0x70(%rbp), %rdx
callq 0x1cdd0
movl %eax, -0x6c(%rbp)
jmp 0xb42c
movl -0x68(%rbp), %edi
cmpl $0x3, -0x44(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %esi
leaq -0x70(%rbp), %rdx
callq 0x1cdd0
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jne 0xb452
leaq 0x15b9f(%rip), %rdi     # 0x20fd8
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xbb27
movl -0x60(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x64(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0xb474
movl -0x6c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x60(%rbp), %edi
movl -0x64(%rbp), %esi
movl -0x6c(%rbp), %edx
xorl %ecx, %ecx
callq 0x13400
cmpl $0x0, %eax
jne 0xb4a9
leaq 0x154a4(%rip), %rdi     # 0x20934
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xbb27
movl -0x60(%rbp), %edi
movl -0x64(%rbp), %esi
movl -0x6c(%rbp), %edx
xorl %ecx, %ecx
callq 0x13640
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0xb4e4
leaq 0x15473(%rip), %rdi     # 0x2093e
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xbb27
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x13350
cmpl $0x0, -0x40(%rbp)
jne 0xb5a4
cmpl $0x0, -0x48(%rbp)
jne 0xb5a4
cmpl $0x0, -0x70(%rbp)
jne 0xb5a4
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
cmpl -0x64(%rbp), %eax
jge 0xb59f
cmpl $0x0, -0x74(%rbp)
je 0xb53d
movl -0x64(%rbp), %eax
subl -0x8c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xe0(%rbp)
jmp 0xb549
movl -0x8c(%rbp), %eax
movl %eax, -0xe0(%rbp)
movl -0xe0(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x80(%rbp), %rax
movl -0xa4(%rbp), %ecx
imull -0x60(%rbp), %ecx
imull -0x6c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movl -0x60(%rbp), %edx
imull -0x6c(%rbp), %edx
callq 0x185b0
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0xb518
jmp 0xba3e
cmpl $0x0, -0x40(%rbp)
je 0xb6e4
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x13350
movl -0x50(%rbp), %edi
movl -0x6c(%rbp), %esi
xorl %edx, %edx
callq 0x13470
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0xb601
movq -0x80(%rbp), %rdi
callq 0x22a0
leaq 0x15356(%rip), %rdi     # 0x2093e
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xbb27
cmpl $0x0, -0x70(%rbp)
je 0xb68f
movq -0x88(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpl $0x3, -0x6c(%rbp)
jne 0xb621
jmp 0xb640
leaq 0x15a4f(%rip), %rdi     # 0x21077
leaq 0x151a7(%rip), %rsi     # 0x207d6
movl $0x15e0, %edx           # imm = 0x15E0
leaq 0x15a51(%rip), %rcx     # 0x2108c
callq 0x2140
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
cmpl -0x50(%rbp), %eax
jge 0xb68d
movq -0x10(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x1ce70
movl -0x6c(%rbp), %ecx
movq -0xb8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0xb64a
jmp 0xb6e2
movq -0x10(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl -0x50(%rbp), %edx
imull -0x6c(%rbp), %edx
callq 0x185b0
cmpl $0x0, %eax
jne 0xb6e0
movq -0x80(%rbp), %rdi
callq 0x22a0
movq -0x88(%rbp), %rdi
callq 0x22a0
leaq 0x15a1a(%rip), %rdi     # 0x210e1
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xbb27
jmp 0xb6e2
jmp 0xb6e4
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl -0x60(%rbp), %ecx
imull -0x64(%rbp), %ecx
cmpl %ecx, %eax
jge 0xb932
cmpl $0x0, -0x48(%rbp)
je 0xb768
cmpl $0x0, -0x98(%rbp)
jne 0xb751
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
movl -0xbc(%rbp), %eax
sarl $0x7, %eax
movl %eax, -0x9c(%rbp)
movl $0x1, -0xa0(%rbp)
jmp 0xb766
cmpl $0x0, -0x9c(%rbp)
jne 0xb764
movl $0x1, -0xa0(%rbp)
jmp 0xb766
jmp 0xb772
movl $0x1, -0xa0(%rbp)
cmpl $0x0, -0xa0(%rbp)
je 0xb8c1
cmpl $0x0, -0x40(%rbp)
je 0xb835
cmpl $0x8, -0x68(%rbp)
jne 0xb7a3
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0xe4(%rbp)
jmp 0xb7b2
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
cmpl -0x50(%rbp), %eax
jl 0xb7d3
movl $0x0, -0xc0(%rbp)
movl -0x6c(%rbp), %eax
imull -0xc0(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl $0x0, -0x90(%rbp)
movl -0x90(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jge 0xb830
movq -0x88(%rbp), %rax
movl -0xc0(%rbp), %ecx
addl -0x90(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq -0x90(%rbp), %rax
movb %cl, -0x94(%rbp,%rax)
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0xb7ed
jmp 0xb8b7
cmpl $0x0, -0x70(%rbp)
je 0xb874
cmpl $0x3, -0x6c(%rbp)
jne 0xb843
jmp 0xb862
leaq 0x1582d(%rip), %rdi     # 0x21077
leaq 0x14f85(%rip), %rsi     # 0x207d6
movl $0x1611, %edx           # imm = 0x1611
leaq 0x1582f(%rip), %rcx     # 0x2108c
callq 0x2140
movq -0x10(%rbp), %rdi
leaq -0x94(%rbp), %rsi
callq 0x1ce70
jmp 0xb8b5
movl $0x0, -0x90(%rbp)
movl -0x90(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jge 0xb8b3
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, %cl
movslq -0x90(%rbp), %rax
movb %cl, -0x94(%rbp,%rax)
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0xb87e
jmp 0xb8b5
jmp 0xb8b7
movl $0x0, -0xa0(%rbp)
movl $0x0, -0x90(%rbp)
movl -0x90(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jge 0xb90f
movslq -0x90(%rbp), %rax
movb -0x94(%rbp,%rax), %dl
movq -0x80(%rbp), %rax
movl -0x8c(%rbp), %ecx
imull -0x6c(%rbp), %ecx
addl -0x90(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0xb8cb
movl -0x98(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x98(%rbp)
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0xb6ee
cmpl $0x0, -0x74(%rbp)
je 0xba26
movl $0x0, -0x90(%rbp)
movl -0x90(%rbp), %eax
shll %eax
cmpl -0x64(%rbp), %eax
jge 0xba24
movl -0x90(%rbp), %eax
imull -0x60(%rbp), %eax
imull -0x6c(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0x64(%rbp), %eax
subl $0x1, %eax
subl -0x90(%rbp), %eax
imull -0x60(%rbp), %eax
imull -0x6c(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0x60(%rbp), %eax
imull -0x6c(%rbp), %eax
movl %eax, -0x8c(%rbp)
cmpl $0x0, -0x8c(%rbp)
jle 0xba0e
movq -0x80(%rbp), %rax
movslq -0xc4(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xc9(%rbp)
movq -0x80(%rbp), %rax
movslq -0xc8(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x80(%rbp), %rax
movslq -0xc4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0xc9(%rbp), %dl
movq -0x80(%rbp), %rax
movslq -0xc8(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc4(%rbp)
movl -0xc8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc8(%rbp)
movl -0x8c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0xb992
jmp 0xba10
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0xb946
jmp 0xba26
cmpq $0x0, -0x88(%rbp)
je 0xba3c
movq -0x88(%rbp), %rdi
callq 0x22a0
jmp 0xba3e
cmpl $0x3, -0x6c(%rbp)
jl 0xbad4
cmpl $0x0, -0x70(%rbp)
jne 0xbad4
movq -0x80(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl -0x60(%rbp), %ecx
imull -0x64(%rbp), %ecx
cmpl %ecx, %eax
jge 0xbad2
movq -0xd8(%rbp), %rax
movb (%rax), %al
movb %al, -0xd9(%rbp)
movq -0xd8(%rbp), %rax
movb 0x2(%rax), %cl
movq -0xd8(%rbp), %rax
movb %cl, (%rax)
movb -0xd9(%rbp), %cl
movq -0xd8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x6c(%rbp), %ecx
movq -0xd8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0xba67
jmp 0xbad4
cmpl $0x0, -0x2c(%rbp)
je 0xbafc
movl -0x2c(%rbp), %eax
cmpl -0x6c(%rbp), %eax
je 0xbafc
movq -0x80(%rbp), %rdi
movl -0x6c(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x60(%rbp), %ecx
movl -0x64(%rbp), %r8d
callq 0x179c0
movq %rax, -0x80(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x58(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)