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

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

  inptr = coef_block;
  quantptr = (FLOAT_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 */
      FAST_FLOAT dcval = 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 = (tmp1 - tmp3) * ((FAST_FLOAT) 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 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */

    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
    tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
    tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */

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

    wsptr[DCTSIZE*0] = tmp0 + tmp7;
    wsptr[DCTSIZE*7] = tmp0 - tmp7;
    wsptr[DCTSIZE*1] = tmp1 + tmp6;
    wsptr[DCTSIZE*6] = tmp1 - tmp6;
    wsptr[DCTSIZE*2] = tmp2 + tmp5;
    wsptr[DCTSIZE*5] = tmp2 - tmp5;
    wsptr[DCTSIZE*4] = tmp3 + tmp4;
    wsptr[DCTSIZE*3] = 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. */

  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).
     * And testing floats for zero is relatively expensive, so we don't bother.
     */
    
    /* Even part */

    tmp10 = wsptr[0] + wsptr[4];
    tmp11 = wsptr[0] - wsptr[4];

    tmp13 = wsptr[2] + wsptr[6];
    tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13;

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

    /* Odd part */

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

    tmp7 = z11 + z13;
    tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562);

    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
    tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
    tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */

    tmp6 = tmp12 - tmp7;
    tmp5 = tmp11 - tmp6;
    tmp4 = tmp10 + tmp5;

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

    outptr[0] = range_limit[(int) DESCALE((INT32) (tmp0 + tmp7), 3)
			    & RANGE_MASK];
    outptr[7] = range_limit[(int) DESCALE((INT32) (tmp0 - tmp7), 3)
			    & RANGE_MASK];
    outptr[1] = range_limit[(int) DESCALE((INT32) (tmp1 + tmp6), 3)
			    & RANGE_MASK];
    outptr[6] = range_limit[(int) DESCALE((INT32) (tmp1 - tmp6), 3)
			    & RANGE_MASK];
    outptr[2] = range_limit[(int) DESCALE((INT32) (tmp2 + tmp5), 3)
			    & RANGE_MASK];
    outptr[5] = range_limit[(int) DESCALE((INT32) (tmp2 - tmp5), 3)
			    & RANGE_MASK];
    outptr[4] = range_limit[(int) DESCALE((INT32) (tmp3 + tmp4), 3)
			    & RANGE_MASK];
    outptr[3] = range_limit[(int) DESCALE((INT32) (tmp3 - tmp4), 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 0xf0a83
movq 0xb8(%rsp), %rax
movswl 0x10(%rax), %eax
cmpl $0x0, %eax
jne 0xf053e
movq 0xb8(%rsp), %rax
movswl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0xf053e
movq 0xb8(%rsp), %rax
movswl 0x30(%rax), %eax
cmpl $0x0, %eax
jne 0xf053e
movq 0xb8(%rsp), %rax
movswl 0x40(%rax), %eax
cmpl $0x0, %eax
jne 0xf053e
movq 0xb8(%rsp), %rax
movswl 0x50(%rax), %eax
cmpl $0x0, %eax
jne 0xf053e
movq 0xb8(%rsp), %rax
movswl 0x60(%rax), %eax
cmpl $0x0, %eax
jne 0xf053e
movq 0xb8(%rsp), %rax
movswl 0x70(%rax), %eax
cmpl $0x0, %eax
jne 0xf053e
movq 0xb8(%rsp), %rax
movswl (%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
mulss (%rax), %xmm0
movss %xmm0, -0x74(%rsp)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, (%rax)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0x20(%rax)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0x40(%rax)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0x60(%rax)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0x80(%rax)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0xa0(%rax)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0xc0(%rax)
movss -0x74(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 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 0xf0a6d
movq 0xb8(%rsp), %rax
movswl (%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
movss (%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x100(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x20(%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
movss 0x40(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0xfc(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x40(%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
movss 0x80(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0xf8(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x60(%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
movss 0xc0(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0xf4(%rsp)
movss 0x100(%rsp), %xmm0
movss 0xf8(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0xe0(%rsp)
movss 0x100(%rsp), %xmm0
movss 0xf8(%rsp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0xdc(%rsp)
movss 0xfc(%rsp), %xmm0
movss 0xf4(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0xd4(%rsp)
movss 0xfc(%rsp), %xmm0
movss 0xf4(%rsp), %xmm1
subss %xmm1, %xmm0
movss 0xd4(%rsp), %xmm1
movss 0x46dde(%rip), %xmm2    # 0x13744c
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0xd8(%rsp)
movss 0xe0(%rsp), %xmm0
movss 0xd4(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x100(%rsp)
movss 0xe0(%rsp), %xmm0
movss 0xd4(%rsp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0xf4(%rsp)
movss 0xdc(%rsp), %xmm0
movss 0xd8(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0xfc(%rsp)
movss 0xdc(%rsp), %xmm0
movss 0xd8(%rsp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0xf8(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x10(%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
movss 0x20(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0xf0(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x30(%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
movss 0x60(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0xec(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x50(%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
movss 0xa0(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0xe8(%rsp)
movq 0xb8(%rsp), %rax
movswl 0x70(%rax), %eax
cvtsi2ss %eax, %xmm0
movq 0xb0(%rsp), %rax
mulss 0xe0(%rax), %xmm0
movss %xmm0, 0xe4(%rsp)
movss 0xe8(%rsp), %xmm0
addss 0xec(%rsp), %xmm0
movss %xmm0, 0xc0(%rsp)
movss 0xe8(%rsp), %xmm0
subss 0xec(%rsp), %xmm0
movss %xmm0, 0xcc(%rsp)
movss 0xf0(%rsp), %xmm0
addss 0xe4(%rsp), %xmm0
movss %xmm0, 0xc8(%rsp)
movss 0xf0(%rsp), %xmm0
subss 0xe4(%rsp), %xmm0
movss %xmm0, 0xc4(%rsp)
movss 0xc8(%rsp), %xmm0
addss 0xc0(%rsp), %xmm0
movss %xmm0, 0xe4(%rsp)
movss 0xc8(%rsp), %xmm0
subss 0xc0(%rsp), %xmm0
movss 0x46c06(%rip), %xmm1    # 0x13744c
mulss %xmm1, %xmm0
movss %xmm0, 0xdc(%rsp)
movss 0xcc(%rsp), %xmm0
addss 0xc4(%rsp), %xmm0
movss 0x46bdb(%rip), %xmm1    # 0x137448
mulss %xmm1, %xmm0
movss %xmm0, 0xd0(%rsp)
movss 0xc4(%rsp), %xmm0
movss 0xd0(%rsp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
movss 0x46ba3(%rip), %xmm2    # 0x137444
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xe0(%rsp)
movss 0xcc(%rsp), %xmm0
movss 0xd0(%rsp), %xmm1
movss 0x46b74(%rip), %xmm2    # 0x137440
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xd8(%rsp)
movss 0xd8(%rsp), %xmm0
subss 0xe4(%rsp), %xmm0
movss %xmm0, 0xe8(%rsp)
movss 0xdc(%rsp), %xmm0
subss 0xe8(%rsp), %xmm0
movss %xmm0, 0xec(%rsp)
movss 0xe0(%rsp), %xmm0
addss 0xec(%rsp), %xmm0
movss %xmm0, 0xf0(%rsp)
movss 0x100(%rsp), %xmm0
addss 0xe4(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, (%rax)
movss 0x100(%rsp), %xmm0
subss 0xe4(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0xe0(%rax)
movss 0xfc(%rsp), %xmm0
addss 0xe8(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0x20(%rax)
movss 0xfc(%rsp), %xmm0
subss 0xe8(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0xc0(%rax)
movss 0xf8(%rsp), %xmm0
addss 0xec(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0x40(%rax)
movss 0xf8(%rsp), %xmm0
subss 0xec(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0xa0(%rax)
movss 0xf4(%rsp), %xmm0
addss 0xf0(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 0x80(%rax)
movss 0xf4(%rsp), %xmm0
subss 0xf0(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movss %xmm0, 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 0xf0398
leaq -0x70(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl $0x0, 0x94(%rsp)
cmpl $0x8, 0x94(%rsp)
jge 0xf0fad
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
movss (%rax), %xmm0
movq 0xa8(%rsp), %rax
addss 0x10(%rax), %xmm0
movss %xmm0, 0xe0(%rsp)
movq 0xa8(%rsp), %rax
movss (%rax), %xmm0
movq 0xa8(%rsp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, 0xdc(%rsp)
movq 0xa8(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0xa8(%rsp), %rax
addss 0x18(%rax), %xmm0
movss %xmm0, 0xd4(%rsp)
movq 0xa8(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0xa8(%rsp), %rax
subss 0x18(%rax), %xmm0
movss 0xd4(%rsp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
movss 0x468de(%rip), %xmm2    # 0x13744c
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xd8(%rsp)
movss 0xe0(%rsp), %xmm0
addss 0xd4(%rsp), %xmm0
movss %xmm0, 0x100(%rsp)
movss 0xe0(%rsp), %xmm0
subss 0xd4(%rsp), %xmm0
movss %xmm0, 0xf4(%rsp)
movss 0xdc(%rsp), %xmm0
addss 0xd8(%rsp), %xmm0
movss %xmm0, 0xfc(%rsp)
movss 0xdc(%rsp), %xmm0
subss 0xd8(%rsp), %xmm0
movss %xmm0, 0xf8(%rsp)
movq 0xa8(%rsp), %rax
movss 0x14(%rax), %xmm0
movq 0xa8(%rsp), %rax
addss 0xc(%rax), %xmm0
movss %xmm0, 0xc0(%rsp)
movq 0xa8(%rsp), %rax
movss 0x14(%rax), %xmm0
movq 0xa8(%rsp), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, 0xcc(%rsp)
movq 0xa8(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0xa8(%rsp), %rax
addss 0x1c(%rax), %xmm0
movss %xmm0, 0xc8(%rsp)
movq 0xa8(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0xa8(%rsp), %rax
subss 0x1c(%rax), %xmm0
movss %xmm0, 0xc4(%rsp)
movss 0xc8(%rsp), %xmm0
addss 0xc0(%rsp), %xmm0
movss %xmm0, 0xe4(%rsp)
movss 0xc8(%rsp), %xmm0
subss 0xc0(%rsp), %xmm0
movss 0x467a0(%rip), %xmm1    # 0x13744c
mulss %xmm1, %xmm0
movss %xmm0, 0xdc(%rsp)
movss 0xcc(%rsp), %xmm0
addss 0xc4(%rsp), %xmm0
movss 0x46775(%rip), %xmm1    # 0x137448
mulss %xmm1, %xmm0
movss %xmm0, 0xd0(%rsp)
movss 0xc4(%rsp), %xmm0
movss 0xd0(%rsp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
movss 0x4673d(%rip), %xmm2    # 0x137444
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xe0(%rsp)
movss 0xcc(%rsp), %xmm0
movss 0xd0(%rsp), %xmm1
movss 0x4670e(%rip), %xmm2    # 0x137440
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xd8(%rsp)
movss 0xd8(%rsp), %xmm0
subss 0xe4(%rsp), %xmm0
movss %xmm0, 0xe8(%rsp)
movss 0xdc(%rsp), %xmm0
subss 0xe8(%rsp), %xmm0
movss %xmm0, 0xec(%rsp)
movss 0xe0(%rsp), %xmm0
addss 0xec(%rsp), %xmm0
movss %xmm0, 0xf0(%rsp)
movq 0x98(%rsp), %rax
movss 0x100(%rsp), %xmm0
addss 0xe4(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, (%rax)
movq 0x98(%rsp), %rax
movss 0x100(%rsp), %xmm0
subss 0xe4(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x7(%rax)
movq 0x98(%rsp), %rax
movss 0xfc(%rsp), %xmm0
addss 0xe8(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x98(%rsp), %rax
movss 0xfc(%rsp), %xmm0
subss 0xe8(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x6(%rax)
movq 0x98(%rsp), %rax
movss 0xf8(%rsp), %xmm0
addss 0xec(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x98(%rsp), %rax
movss 0xf8(%rsp), %xmm0
subss 0xec(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x5(%rax)
movq 0x98(%rsp), %rax
movss 0xf4(%rsp), %xmm0
addss 0xf0(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
andl $0x3ff, %ecx            # imm = 0x3FF
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0xa0(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x98(%rsp), %rax
movss 0xf4(%rsp), %xmm0
subss 0xf0(%rsp), %xmm0
cvttss2si %xmm0, %rcx
addq $0x4, %rcx
sarq $0x3, %rcx
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 0xf0a9b
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
nop