// File: tomfunkhouser[P]gaps/pkgs/jpeg/jidctfst.c
// Function: jpeg_idct_ifast
GLOBAL(void)
jpeg_idct_ifast (j_decompress_ptr cinfo, jpeg_component_info * compptr,
		 JCOEFPTR coef_block,
		 JSAMPARRAY output_buf, JDIMENSION output_col)
{
  DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  DCTELEM tmp10, tmp11, tmp12, tmp13;
  DCTELEM z5, z10, z11, z12, z13;
  JCOEFPTR inptr;
  IFAST_MULT_TYPE * quantptr;
  int * wsptr;
  JSAMPROW outptr;
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
  int ctr;
  int workspace[DCTSIZE2];	/* buffers data between passes */
  SHIFT_TEMPS			/* for DESCALE */
  ISHIFT_TEMPS			/* for IDESCALE */

  /* Pass 1: process columns from input, store into work array. */

  inptr = coef_block;
  quantptr = (IFAST_MULT_TYPE *) compptr->dct_table;
  wsptr = workspace;
  for (ctr = DCTSIZE; ctr > 0; ctr--) {
    /* Due to quantization, we will usually find that many of the input
     * coefficients are zero, especially the AC terms.  We can exploit this
     * by short-circuiting the IDCT calculation for any column in which all
     * the AC terms are zero.  In that case each output is equal to the
     * DC coefficient (with scale factor as needed).
     * With typical images and quantization tables, half or more of the
     * column DCT calculations can be simplified this way.
     */
    
    if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
	inptr[DCTSIZE*7] == 0) {
      /* AC terms all zero */
      int dcval = (int) DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);

      wsptr[DCTSIZE*0] = dcval;
      wsptr[DCTSIZE*1] = dcval;
      wsptr[DCTSIZE*2] = dcval;
      wsptr[DCTSIZE*3] = dcval;
      wsptr[DCTSIZE*4] = dcval;
      wsptr[DCTSIZE*5] = dcval;
      wsptr[DCTSIZE*6] = dcval;
      wsptr[DCTSIZE*7] = dcval;
      
      inptr++;			/* advance pointers to next column */
      quantptr++;
      wsptr++;
      continue;
    }
    
    /* Even part */

    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);

    tmp10 = tmp0 + tmp2;	/* phase 3 */
    tmp11 = tmp0 - tmp2;

    tmp13 = tmp1 + tmp3;	/* phases 5-3 */
    tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */

    tmp0 = tmp10 + tmp13;	/* phase 2 */
    tmp3 = tmp10 - tmp13;
    tmp1 = tmp11 + tmp12;
    tmp2 = tmp11 - tmp12;
    
    /* Odd part */

    tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);

    z13 = tmp6 + tmp5;		/* phase 6 */
    z10 = tmp6 - tmp5;
    z11 = tmp4 + tmp7;
    z12 = tmp4 - tmp7;

    tmp7 = z11 + z13;		/* phase 5 */
    tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */

    z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
    tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */

    tmp6 = tmp12 - tmp7;	/* phase 2 */
    tmp5 = tmp11 - tmp6;
    tmp4 = tmp10 + tmp5;

    wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7);
    wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7);
    wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6);
    wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6);
    wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5);
    wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5);
    wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4);
    wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4);

    inptr++;			/* advance pointers to next column */
    quantptr++;
    wsptr++;
  }
  
  /* Pass 2: process rows from work array, store into output array. */
  /* Note that we must descale the results by a factor of 8 == 2**3, */
  /* and also undo the PASS1_BITS scaling. */

  wsptr = workspace;
  for (ctr = 0; ctr < DCTSIZE; ctr++) {
    outptr = output_buf[ctr] + output_col;
    /* Rows of zeroes can be exploited in the same way as we did with columns.
     * However, the column calculation has created many nonzero AC terms, so
     * the simplification applies less often (typically 5% to 10% of the time).
     * On machines with very fast multiplication, it's possible that the
     * test takes more time than it's worth.  In that case this section
     * may be commented out.
     */
    
#ifndef NO_ZERO_ROW_TEST
    if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
	wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
      /* AC terms all zero */
      JSAMPLE dcval = range_limit[IDESCALE(wsptr[0], PASS1_BITS+3)
				  & RANGE_MASK];
      
      outptr[0] = dcval;
      outptr[1] = dcval;
      outptr[2] = dcval;
      outptr[3] = dcval;
      outptr[4] = dcval;
      outptr[5] = dcval;
      outptr[6] = dcval;
      outptr[7] = dcval;

      wsptr += DCTSIZE;		/* advance pointer to next row */
      continue;
    }
#endif
    
    /* Even part */

    tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]);
    tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]);

    tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]);
    tmp12 = MULTIPLY((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6], FIX_1_414213562)
	    - tmp13;

    tmp0 = tmp10 + tmp13;
    tmp3 = tmp10 - tmp13;
    tmp1 = tmp11 + tmp12;
    tmp2 = tmp11 - tmp12;

    /* Odd part */

    z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3];
    z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3];
    z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7];
    z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7];

    tmp7 = z11 + z13;		/* phase 5 */
    tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */

    z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
    tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */

    tmp6 = tmp12 - tmp7;	/* phase 2 */
    tmp5 = tmp11 - tmp6;
    tmp4 = tmp10 + tmp5;

    /* Final output stage: scale down by a factor of 8 and range-limit */

    outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3)
			    & RANGE_MASK];
    outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3)
			    & RANGE_MASK];
    outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3)
			    & RANGE_MASK];
    outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3)
			    & RANGE_MASK];
    outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3)
			    & RANGE_MASK];
    outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3)
			    & RANGE_MASK];
    outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3)
			    & RANGE_MASK];
    outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3)
			    & RANGE_MASK];

    wsptr += DCTSIZE;		/* advance pointer to next row */
  }
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x108(%rsp)
movl %r8d, 0x104(%rsp)
movq 0x120(%rsp), %rax
movq 0x1a8(%rax), %rax
addq $0x80, %rax
movq %rax, 0x98(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x118(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0xb0(%rsp)
leaq -0x70(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl $0x8, 0x94(%rsp)
cmpl $0x0, 0x94(%rsp)
jle 0xefdb8
movq 0xb8(%rsp), %rax
movswl 0x10(%rax), %eax
cmpl $0x0, %eax
jne 0xef9a7
movq 0xb8(%rsp), %rax
movswl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0xef9a7
movq 0xb8(%rsp), %rax
movswl 0x30(%rax), %eax
cmpl $0x0, %eax
jne 0xef9a7
movq 0xb8(%rsp), %rax
movswl 0x40(%rax), %eax
cmpl $0x0, %eax
jne 0xef9a7
movq 0xb8(%rsp), %rax
movswl 0x50(%rax), %eax
cmpl $0x0, %eax
jne 0xef9a7
movq 0xb8(%rsp), %rax
movswl 0x60(%rax), %eax
cmpl $0x0, %eax
jne 0xef9a7
movq 0xb8(%rsp), %rax
movswl 0x70(%rax), %eax
cmpl $0x0, %eax
jne 0xef9a7
movq 0xb8(%rsp), %rax
movswl (%rax), %eax
movq 0xb0(%rsp), %rcx
imull (%rcx), %eax
movl %eax, -0x74(%rsp)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, (%rax)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x20(%rax)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x40(%rax)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x60(%rax)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x80(%rax)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xa0(%rax)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xc0(%rax)
movl -0x74(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xe0(%rax)
movq 0xb8(%rsp), %rax
addq $0x2, %rax
movq %rax, 0xb8(%rsp)
movq 0xb0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xa8(%rsp)
jmp 0xefda2
movq 0xb8(%rsp), %rax
movswl (%rax), %eax
movq 0xb0(%rsp), %rcx
imull (%rcx), %eax
movl %eax, 0x100(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x20(%rax), %eax
movq 0xb0(%rsp), %rcx
imull 0x40(%rcx), %eax
movl %eax, 0xfc(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x40(%rax), %eax
movq 0xb0(%rsp), %rcx
imull 0x80(%rcx), %eax
movl %eax, 0xf8(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x60(%rax), %eax
movq 0xb0(%rsp), %rcx
imull 0xc0(%rcx), %eax
movl %eax, 0xf4(%rsp)
movl 0x100(%rsp), %eax
addl 0xf8(%rsp), %eax
movl %eax, 0xe0(%rsp)
movl 0x100(%rsp), %eax
subl 0xf8(%rsp), %eax
movl %eax, 0xdc(%rsp)
movl 0xfc(%rsp), %eax
addl 0xf4(%rsp), %eax
movl %eax, 0xd4(%rsp)
movl 0xfc(%rsp), %eax
subl 0xf4(%rsp), %eax
cltq
imulq $0x16a, %rax, %rax      # imm = 0x16A
sarq $0x8, %rax
subl 0xd4(%rsp), %eax
movl %eax, 0xd8(%rsp)
movl 0xe0(%rsp), %eax
addl 0xd4(%rsp), %eax
movl %eax, 0x100(%rsp)
movl 0xe0(%rsp), %eax
subl 0xd4(%rsp), %eax
movl %eax, 0xf4(%rsp)
movl 0xdc(%rsp), %eax
addl 0xd8(%rsp), %eax
movl %eax, 0xfc(%rsp)
movl 0xdc(%rsp), %eax
subl 0xd8(%rsp), %eax
movl %eax, 0xf8(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x10(%rax), %eax
movq 0xb0(%rsp), %rcx
imull 0x20(%rcx), %eax
movl %eax, 0xf0(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x30(%rax), %eax
movq 0xb0(%rsp), %rcx
imull 0x60(%rcx), %eax
movl %eax, 0xec(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x50(%rax), %eax
movq 0xb0(%rsp), %rcx
imull 0xa0(%rcx), %eax
movl %eax, 0xe8(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x70(%rax), %eax
movq 0xb0(%rsp), %rcx
imull 0xe0(%rcx), %eax
movl %eax, 0xe4(%rsp)
movl 0xe8(%rsp), %eax
addl 0xec(%rsp), %eax
movl %eax, 0xc0(%rsp)
movl 0xe8(%rsp), %eax
subl 0xec(%rsp), %eax
movl %eax, 0xcc(%rsp)
movl 0xf0(%rsp), %eax
addl 0xe4(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0xf0(%rsp), %eax
subl 0xe4(%rsp), %eax
movl %eax, 0xc4(%rsp)
movl 0xc8(%rsp), %eax
addl 0xc0(%rsp), %eax
movl %eax, 0xe4(%rsp)
movl 0xc8(%rsp), %eax
subl 0xc0(%rsp), %eax
cltq
imulq $0x16a, %rax, %rax      # imm = 0x16A
sarq $0x8, %rax
movl %eax, 0xdc(%rsp)
movl 0xcc(%rsp), %eax
addl 0xc4(%rsp), %eax
cltq
imulq $0x1d9, %rax, %rax      # imm = 0x1D9
sarq $0x8, %rax
movl %eax, 0xd0(%rsp)
movslq 0xc4(%rsp), %rax
imulq $0x115, %rax, %rax      # imm = 0x115
sarq $0x8, %rax
subl 0xd0(%rsp), %eax
movl %eax, 0xe0(%rsp)
movslq 0xcc(%rsp), %rax
imulq $-0x29d, %rax, %rax     # imm = 0xFD63
sarq $0x8, %rax
addl 0xd0(%rsp), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
subl 0xe4(%rsp), %eax
movl %eax, 0xe8(%rsp)
movl 0xdc(%rsp), %eax
subl 0xe8(%rsp), %eax
movl %eax, 0xec(%rsp)
movl 0xe0(%rsp), %eax
addl 0xec(%rsp), %eax
movl %eax, 0xf0(%rsp)
movl 0x100(%rsp), %ecx
addl 0xe4(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, (%rax)
movl 0x100(%rsp), %ecx
subl 0xe4(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xe0(%rax)
movl 0xfc(%rsp), %ecx
addl 0xe8(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0xfc(%rsp), %ecx
subl 0xe8(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xc0(%rax)
movl 0xf8(%rsp), %ecx
addl 0xec(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x40(%rax)
movl 0xf8(%rsp), %ecx
subl 0xec(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xa0(%rax)
movl 0xf4(%rsp), %ecx
addl 0xf0(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x80(%rax)
movl 0xf4(%rsp), %ecx
subl 0xf0(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x60(%rax)
movq 0xb8(%rsp), %rax
addq $0x2, %rax
movq %rax, 0xb8(%rsp)
movq 0xb0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xa8(%rsp)
movl 0x94(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0xef828
leaq -0x70(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl $0x0, 0x94(%rsp)
cmpl $0x8, 0x94(%rsp)
jge 0xf0308
movq 0x108(%rsp), %rax
movslq 0x94(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x104(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xeff37
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xeff37
movq 0xa8(%rsp), %rax
cmpl $0x0, 0xc(%rax)
jne 0xeff37
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xeff37
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xeff37
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xeff37
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0xeff37
movq 0x98(%rsp), %rax
movq 0xa8(%rsp), %rcx
movl (%rcx), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x75(%rsp)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, (%rax)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x1(%rax)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x2(%rax)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x3(%rax)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x4(%rax)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x5(%rax)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x6(%rax)
movb -0x75(%rsp), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x7(%rax)
movq 0xa8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0xa8(%rsp)
jmp 0xf02f2
movq 0xa8(%rsp), %rax
movl (%rax), %eax
movq 0xa8(%rsp), %rcx
addl 0x10(%rcx), %eax
movl %eax, 0xe0(%rsp)
movq 0xa8(%rsp), %rax
movl (%rax), %eax
movq 0xa8(%rsp), %rcx
subl 0x10(%rcx), %eax
movl %eax, 0xdc(%rsp)
movq 0xa8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0xa8(%rsp), %rcx
addl 0x18(%rcx), %eax
movl %eax, 0xd4(%rsp)
movq 0xa8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0xa8(%rsp), %rcx
subl 0x18(%rcx), %eax
cltq
imulq $0x16a, %rax, %rax      # imm = 0x16A
sarq $0x8, %rax
subl 0xd4(%rsp), %eax
movl %eax, 0xd8(%rsp)
movl 0xe0(%rsp), %eax
addl 0xd4(%rsp), %eax
movl %eax, 0x100(%rsp)
movl 0xe0(%rsp), %eax
subl 0xd4(%rsp), %eax
movl %eax, 0xf4(%rsp)
movl 0xdc(%rsp), %eax
addl 0xd8(%rsp), %eax
movl %eax, 0xfc(%rsp)
movl 0xdc(%rsp), %eax
subl 0xd8(%rsp), %eax
movl %eax, 0xf8(%rsp)
movq 0xa8(%rsp), %rax
movl 0x14(%rax), %eax
movq 0xa8(%rsp), %rcx
addl 0xc(%rcx), %eax
movl %eax, 0xc0(%rsp)
movq 0xa8(%rsp), %rax
movl 0x14(%rax), %eax
movq 0xa8(%rsp), %rcx
subl 0xc(%rcx), %eax
movl %eax, 0xcc(%rsp)
movq 0xa8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0xa8(%rsp), %rcx
addl 0x1c(%rcx), %eax
movl %eax, 0xc8(%rsp)
movq 0xa8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0xa8(%rsp), %rcx
subl 0x1c(%rcx), %eax
movl %eax, 0xc4(%rsp)
movl 0xc8(%rsp), %eax
addl 0xc0(%rsp), %eax
movl %eax, 0xe4(%rsp)
movl 0xc8(%rsp), %eax
subl 0xc0(%rsp), %eax
cltq
imulq $0x16a, %rax, %rax      # imm = 0x16A
sarq $0x8, %rax
movl %eax, 0xdc(%rsp)
movl 0xcc(%rsp), %eax
addl 0xc4(%rsp), %eax
cltq
imulq $0x1d9, %rax, %rax      # imm = 0x1D9
sarq $0x8, %rax
movl %eax, 0xd0(%rsp)
movslq 0xc4(%rsp), %rax
imulq $0x115, %rax, %rax      # imm = 0x115
sarq $0x8, %rax
subl 0xd0(%rsp), %eax
movl %eax, 0xe0(%rsp)
movslq 0xcc(%rsp), %rax
imulq $-0x29d, %rax, %rax     # imm = 0xFD63
sarq $0x8, %rax
addl 0xd0(%rsp), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
subl 0xe4(%rsp), %eax
movl %eax, 0xe8(%rsp)
movl 0xdc(%rsp), %eax
subl 0xe8(%rsp), %eax
movl %eax, 0xec(%rsp)
movl 0xe0(%rsp), %eax
addl 0xec(%rsp), %eax
movl %eax, 0xf0(%rsp)
movq 0x98(%rsp), %rax
movl 0x100(%rsp), %ecx
addl 0xe4(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, (%rax)
movq 0x98(%rsp), %rax
movl 0x100(%rsp), %ecx
subl 0xe4(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x7(%rax)
movq 0x98(%rsp), %rax
movl 0xfc(%rsp), %ecx
addl 0xe8(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x98(%rsp), %rax
movl 0xfc(%rsp), %ecx
subl 0xe8(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x6(%rax)
movq 0x98(%rsp), %rax
movl 0xf8(%rsp), %ecx
addl 0xec(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x98(%rsp), %rax
movl 0xf8(%rsp), %ecx
subl 0xec(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x5(%rax)
movq 0x98(%rsp), %rax
movl 0xf4(%rsp), %ecx
addl 0xf0(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x98(%rsp), %rax
movl 0xf4(%rsp), %ecx
subl 0xf0(%rsp), %ecx
sarl $0x5, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x3(%rax)
movq 0xa8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0xa8(%rsp)
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0xefdd0
addq $0x128, %rsp            # imm = 0x128
retq