void fdct_and_quantization(signed char *data, float *fdtbl,
                           signed short int *outdata) {
  float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  float tmp10, tmp11, tmp12, tmp13;
  float z1, z2, z3, z4, z5, z11, z13;
  float *dataptr;
  float datafloat[64];
  float temp;
  signed char ctr;
  unsigned char i;
  for (i = 0; i < 64; i++)
    datafloat[i] = data[i];
  dataptr = datafloat;
  for (ctr = 7; ctr >= 0; ctr--) {
    tmp0 = dataptr[0] + dataptr[7];
    tmp7 = dataptr[0] - dataptr[7];
    tmp1 = dataptr[1] + dataptr[6];
    tmp6 = dataptr[1] - dataptr[6];
    tmp2 = dataptr[2] + dataptr[5];
    tmp5 = dataptr[2] - dataptr[5];
    tmp3 = dataptr[3] + dataptr[4];
    tmp4 = dataptr[3] - dataptr[4];
    tmp10 = tmp0 + tmp3;
    tmp13 = tmp0 - tmp3;
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;
    dataptr[0] = tmp10 + tmp11;
    dataptr[4] = tmp10 - tmp11;
    z1 = (tmp12 + tmp13) * ((float)0.707106781);
    dataptr[2] = tmp13 + z1;
    dataptr[6] = tmp13 - z1;
    tmp10 = tmp4 + tmp5;
    tmp11 = tmp5 + tmp6;
    tmp12 = tmp6 + tmp7;
    z5 = (tmp10 - tmp12) * ((float)0.382683433);
    z2 = ((float)0.541196100) * tmp10 + z5;
    z4 = ((float)1.306562965) * tmp12 + z5;
    z3 = tmp11 * ((float)0.707106781);
    z11 = tmp7 + z3;
    z13 = tmp7 - z3;
    dataptr[5] = z13 + z2;
    dataptr[3] = z13 - z2;
    dataptr[1] = z11 + z4;
    dataptr[7] = z11 - z4;
    dataptr += 8;
  }
  dataptr = datafloat;
  for (ctr = 7; ctr >= 0; ctr--) {
    tmp0 = dataptr[0] + dataptr[56];
    tmp7 = dataptr[0] - dataptr[56];
    tmp1 = dataptr[8] + dataptr[48];
    tmp6 = dataptr[8] - dataptr[48];
    tmp2 = dataptr[16] + dataptr[40];
    tmp5 = dataptr[16] - dataptr[40];
    tmp3 = dataptr[24] + dataptr[32];
    tmp4 = dataptr[24] - dataptr[32];
    tmp10 = tmp0 + tmp3;
    tmp13 = tmp0 - tmp3;
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;
    dataptr[0] = tmp10 + tmp11;
    dataptr[32] = tmp10 - tmp11;
    z1 = (tmp12 + tmp13) * ((float)0.707106781);
    dataptr[16] = tmp13 + z1;
    dataptr[48] = tmp13 - z1;
    tmp10 = tmp4 + tmp5;
    tmp11 = tmp5 + tmp6;
    tmp12 = tmp6 + tmp7;
    z5 = (tmp10 - tmp12) * ((float)0.382683433);
    z2 = ((float)0.541196100) * tmp10 + z5;
    z4 = ((float)1.306562965) * tmp12 + z5;
    z3 = tmp11 * ((float)0.707106781);
    z11 = tmp7 + z3;
    z13 = tmp7 - z3;
    dataptr[40] = z13 + z2;
    dataptr[24] = z13 - z2;
    dataptr[8] = z11 + z4;
    dataptr[56] = z11 - z4;
    dataptr++;
  }
  for (i = 0; i < 64; i++) {
    temp = datafloat[i] * fdtbl[i];
    outdata[i] = (signed short int)((signed short int)(temp + 16384.5) - 16384);
  }
}


x86 assembly (clang, -O0):
<fdct_and_quantization>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movb   $0x0,-0x176(%rbp)
movzbl -0x176(%rbp),%eax
cmp    $0x40,%eax
jge    1164 <fdct_and_quantization+0x64>
mov    -0x8(%rbp),%rax
movzbl -0x176(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movzbl -0x176(%rbp),%eax
movss  %xmm0,-0x170(%rbp,%rax,4)
ff ff
mov    -0x176(%rbp),%al
add    $0x1,%al
mov    %al,-0x176(%rbp)
jmp    111e <fdct_and_quantization+0x1e>
lea    -0x170(%rbp),%rax
mov    %rax,-0x70(%rbp)
movb   $0x7,-0x175(%rbp)
movsbl -0x175(%rbp),%eax
cmp    $0x0,%eax
jl     13ff <fdct_and_quantization+0x2ff>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0x1c(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0x18(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x70(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x70(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0x14(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x70(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x70(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0x10(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x44(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  0xd59(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  0xcf7(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
movss  0xcd8(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
movss  0xcb5(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0xc9c(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x60(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x60(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x70(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x70(%rbp)
mov    -0x175(%rbp),%al
add    $0xff,%al
mov    %al,-0x175(%rbp)
jmp    1176 <fdct_and_quantization+0x76>
lea    -0x170(%rbp),%rax
mov    %rax,-0x70(%rbp)
movb   $0x7,-0x175(%rbp)
movsbl -0x175(%rbp),%eax
cmp    $0x0,%eax
jl     16be <fdct_and_quantization+0x5be>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0xe0(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0xe0(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x70(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0xc0(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x70(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0xc0(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x70(%rbp),%rax
movss  0x40(%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0xa0(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x70(%rbp),%rax
movss  0x40(%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0xa0(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x70(%rbp),%rax
movss  0x60(%rax),%xmm0
mov    -0x70(%rbp),%rax
addss  0x80(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x70(%rbp),%rax
movss  0x60(%rax),%xmm0
mov    -0x70(%rbp),%rax
subss  0x80(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x80(%rax)
movss  -0x44(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  0xaa3(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x40(%rax)
movss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0xc0(%rax)
movss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  0xa3e(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
movss  0xa1f(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
movss  0x9fc(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0x9e3(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0xa0(%rax)
movss  -0x64(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x60(%rax)
movss  -0x60(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x60(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0xe0(%rax)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x175(%rbp),%al
add    $0xff,%al
mov    %al,-0x175(%rbp)
jmp    1411 <fdct_and_quantization+0x311>
movb   $0x0,-0x176(%rbp)
movzbl -0x176(%rbp),%eax
cmp    $0x40,%eax
jge    1743 <fdct_and_quantization+0x643>
movzbl -0x176(%rbp),%eax
mov    %eax,%ecx
movss  -0x170(%rbp,%rcx,4),%xmm0
ff ff
mov    -0x10(%rbp),%rax
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x174(%rbp)
ff
movss  -0x174(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x8f0(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
cwtl
sub    $0x4000,%eax
mov    %ax,%dx
mov    -0x18(%rbp),%rax
movzbl -0x176(%rbp),%ecx
mov    %dx,(%rax,%rcx,2)
mov    -0x176(%rbp),%al
add    $0x1,%al
mov    %al,-0x176(%rbp)
jmp    16c5 <fdct_and_quantization+0x5c5>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fdct_and_quantization>:
sub    $0xa8,%rsp
movd   (%rdi),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
cvtdq2ps %xmm0,%xmm3
movaps %xmm3,-0x80(%rsp)
movd   0x4(%rdi),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
cvtdq2ps %xmm0,%xmm8
movaps %xmm8,-0x70(%rsp)
movd   0x8(%rdi),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
cvtdq2ps %xmm0,%xmm4
movaps %xmm4,-0x60(%rsp)
movd   0xc(%rdi),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
cvtdq2ps %xmm0,%xmm1
movaps %xmm1,-0x50(%rsp)
movd   0x10(%rdi),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
cvtdq2ps %xmm0,%xmm0
movaps %xmm0,-0x40(%rsp)
movd   0x14(%rdi),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm2
cvtdq2ps %xmm2,%xmm12
movaps %xmm12,-0x30(%rsp)
movd   0x18(%rdi),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm2
cvtdq2ps %xmm2,%xmm5
movaps %xmm5,-0x20(%rsp)
movd   0x1c(%rdi),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm2
cvtdq2ps %xmm2,%xmm10
movaps %xmm10,-0x10(%rsp)
movaps %xmm3,%xmm11
unpcklps %xmm4,%xmm11
movaps %xmm5,%xmm2
movlhps %xmm0,%xmm2
shufps $0x24,%xmm2,%xmm11
movaps %xmm4,%xmm6
shufps $0x11,%xmm3,%xmm6
movaps %xmm0,%xmm2
unpcklps %xmm5,%xmm2
shufps $0xe2,%xmm2,%xmm6
movaps %xmm3,%xmm2
unpckhps %xmm4,%xmm2
movaps %xmm5,%xmm7
unpckhpd %xmm0,%xmm7
shufps $0x24,%xmm7,%xmm2
shufps $0x33,%xmm3,%xmm4
unpckhps %xmm5,%xmm0
shufps $0xe2,%xmm0,%xmm4
movaps %xmm8,%xmm0
unpcklps %xmm1,%xmm0
movaps %xmm10,%xmm5
movlhps %xmm12,%xmm5
shufps $0x24,%xmm5,%xmm0
movaps %xmm1,%xmm5
shufps $0x11,%xmm8,%xmm5
movaps %xmm12,%xmm7
unpcklps %xmm10,%xmm7
shufps $0xe2,%xmm7,%xmm5
movaps %xmm8,%xmm3
unpckhps %xmm1,%xmm3
movaps %xmm10,%xmm7
unpckhpd %xmm12,%xmm7
shufps $0x24,%xmm7,%xmm3
shufps $0x33,%xmm8,%xmm1
unpckhps %xmm10,%xmm12
shufps $0xe2,%xmm12,%xmm1
movaps %xmm11,%xmm7
addps  %xmm1,%xmm7
subps  %xmm1,%xmm11
movaps %xmm6,%xmm1
addps  %xmm3,%xmm1
subps  %xmm3,%xmm6
movaps %xmm2,%xmm3
addps  %xmm5,%xmm3
subps  %xmm5,%xmm2
movaps %xmm4,%xmm5
addps  %xmm0,%xmm5
subps  %xmm0,%xmm4
movaps %xmm7,%xmm13
addps  %xmm5,%xmm13
subps  %xmm5,%xmm7
movaps %xmm1,%xmm0
addps  %xmm3,%xmm0
subps  %xmm3,%xmm1
movaps %xmm0,%xmm10
addps  %xmm13,%xmm10
subps  %xmm0,%xmm13
addps  %xmm7,%xmm1
movaps 0xd4b(%rip),%xmm0
mulps  %xmm0,%xmm1
movaps %xmm0,%xmm3
movaps %xmm7,%xmm0
addps  %xmm1,%xmm0
subps  %xmm1,%xmm7
addps  %xmm2,%xmm4
addps  %xmm6,%xmm2
addps  %xmm11,%xmm6
movaps %xmm4,%xmm1
subps  %xmm6,%xmm1
mulps  0xd35(%rip),%xmm1
mulps  0xd3e(%rip),%xmm4
addps  %xmm1,%xmm4
mulps  0xd44(%rip),%xmm6
addps  %xmm1,%xmm6
mulps  %xmm3,%xmm2
movaps %xmm11,%xmm5
addps  %xmm2,%xmm5
subps  %xmm2,%xmm11
movaps %xmm11,%xmm9
addps  %xmm4,%xmm9
subps  %xmm4,%xmm11
movaps %xmm5,%xmm8
addps  %xmm6,%xmm8
subps  %xmm6,%xmm5
movaps %xmm5,%xmm1
movlhps %xmm7,%xmm1
movaps %xmm13,%xmm2
unpcklps %xmm9,%xmm2
shufps $0x24,%xmm1,%xmm2
movaps %xmm2,0x90(%rsp)
movaps %xmm11,%xmm1
movlhps %xmm0,%xmm1
movaps %xmm10,%xmm2
unpcklps %xmm8,%xmm2
shufps $0x24,%xmm1,%xmm2
movaps %xmm2,0x80(%rsp)
movaps %xmm7,%xmm1
unpcklps %xmm5,%xmm1
movaps %xmm9,%xmm15
shufps $0x11,%xmm13,%xmm15
shufps $0xe2,%xmm1,%xmm15
movaps %xmm0,%xmm3
unpcklps %xmm11,%xmm3
movaps %xmm8,%xmm2
shufps $0x11,%xmm10,%xmm2
shufps $0xe2,%xmm3,%xmm2
movaps %xmm5,%xmm6
unpckhpd %xmm7,%xmm6
movaps %xmm13,%xmm3
unpckhps %xmm9,%xmm3
shufps $0x24,%xmm6,%xmm3
movaps %xmm11,%xmm6
unpckhpd %xmm0,%xmm6
movaps %xmm10,%xmm12
unpckhps %xmm8,%xmm12
shufps $0x24,%xmm6,%xmm12
unpckhps %xmm5,%xmm7
shufps $0x33,%xmm13,%xmm9
shufps $0xe2,%xmm7,%xmm9
movd   0x20(%rdi),%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
psrad  $0x18,%xmm5
cvtdq2ps %xmm5,%xmm13
movaps %xmm13,(%rsp)
unpckhps %xmm11,%xmm0
movd   0x24(%rdi),%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
psrad  $0x18,%xmm5
cvtdq2ps %xmm5,%xmm11
movaps %xmm11,0x10(%rsp)
shufps $0x33,%xmm10,%xmm8
movd   0x28(%rdi),%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
psrad  $0x18,%xmm5
cvtdq2ps %xmm5,%xmm6
movaps %xmm6,0x20(%rsp)
shufps $0xe2,%xmm0,%xmm8
movd   0x2c(%rdi),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
cvtdq2ps %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movd   0x30(%rdi),%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
psrad  $0x18,%xmm5
cvtdq2ps %xmm5,%xmm7
movaps %xmm7,0x40(%rsp)
movd   0x34(%rdi),%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
psrad  $0x18,%xmm5
cvtdq2ps %xmm5,%xmm4
movaps %xmm4,0x50(%rsp)
movd   0x38(%rdi),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
cvtdq2ps %xmm1,%xmm14
movaps %xmm14,0x60(%rsp)
movd   0x3c(%rdi),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
cvtdq2ps %xmm1,%xmm10
movaps %xmm10,0x70(%rsp)
movaps %xmm8,-0x20(%rsp)
movaps %xmm9,-0x10(%rsp)
movaps %xmm12,-0x40(%rsp)
movaps %xmm3,-0x30(%rsp)
movaps %xmm2,-0x60(%rsp)
movaps %xmm15,-0x50(%rsp)
movaps 0x80(%rsp),%xmm1
movaps %xmm1,-0x80(%rsp)
movaps 0x90(%rsp),%xmm1
movaps %xmm1,-0x70(%rsp)
movaps %xmm13,%xmm15
unpcklps %xmm6,%xmm15
movaps %xmm14,%xmm1
movlhps %xmm7,%xmm1
shufps $0x24,%xmm1,%xmm15
movaps %xmm6,%xmm1
shufps $0x11,%xmm13,%xmm1
movaps %xmm7,%xmm3
unpcklps %xmm14,%xmm3
shufps $0xe2,%xmm3,%xmm1
movaps %xmm13,%xmm3
unpckhps %xmm6,%xmm3
movaps %xmm14,%xmm2
unpckhpd %xmm7,%xmm2
shufps $0x24,%xmm2,%xmm3
shufps $0x33,%xmm13,%xmm6
unpckhps %xmm14,%xmm7
shufps $0xe2,%xmm7,%xmm6
movaps %xmm11,%xmm8
unpcklps %xmm0,%xmm8
movaps %xmm10,%xmm2
movlhps %xmm4,%xmm2
shufps $0x24,%xmm2,%xmm8
movaps %xmm0,%xmm2
shufps $0x11,%xmm11,%xmm2
movaps %xmm4,%xmm5
unpcklps %xmm10,%xmm5
shufps $0xe2,%xmm5,%xmm2
movaps %xmm11,%xmm5
unpckhps %xmm0,%xmm5
movaps %xmm10,%xmm7
unpckhpd %xmm4,%xmm7
shufps $0x24,%xmm7,%xmm5
shufps $0x33,%xmm11,%xmm0
unpckhps %xmm10,%xmm4
shufps $0xe2,%xmm4,%xmm0
movaps %xmm15,%xmm10
addps  %xmm0,%xmm10
subps  %xmm0,%xmm15
movaps %xmm1,%xmm0
addps  %xmm5,%xmm0
subps  %xmm5,%xmm1
movaps %xmm3,%xmm4
addps  %xmm2,%xmm4
subps  %xmm2,%xmm3
movaps %xmm6,%xmm2
addps  %xmm8,%xmm2
subps  %xmm8,%xmm6
movaps %xmm10,%xmm9
addps  %xmm2,%xmm9
subps  %xmm2,%xmm10
movaps %xmm0,%xmm2
addps  %xmm4,%xmm2
subps  %xmm4,%xmm0
movaps %xmm2,%xmm12
addps  %xmm9,%xmm12
subps  %xmm2,%xmm9
addps  %xmm10,%xmm0
movaps 0xa56(%rip),%xmm2
mulps  %xmm2,%xmm0
movaps %xmm10,%xmm8
addps  %xmm0,%xmm8
subps  %xmm0,%xmm10
addps  %xmm3,%xmm6
addps  %xmm1,%xmm3
addps  %xmm15,%xmm1
movaps %xmm6,%xmm0
subps  %xmm1,%xmm0
mulps  0xa40(%rip),%xmm0
mulps  0xa49(%rip),%xmm6
addps  %xmm0,%xmm6
mulps  0xa4f(%rip),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm2,%xmm3
movaps %xmm15,%xmm5
addps  %xmm3,%xmm5
subps  %xmm3,%xmm15
movaps %xmm15,%xmm0
addps  %xmm6,%xmm0
subps  %xmm6,%xmm15
movaps %xmm5,%xmm3
addps  %xmm1,%xmm3
subps  %xmm1,%xmm5
movaps %xmm10,%xmm1
unpckhps %xmm5,%xmm1
movaps %xmm0,%xmm13
shufps $0x33,%xmm9,%xmm13
shufps $0xe2,%xmm1,%xmm13
movaps %xmm5,%xmm1
movlhps %xmm10,%xmm1
movaps %xmm9,%xmm6
unpcklps %xmm0,%xmm6
shufps $0x24,%xmm1,%xmm6
movaps %xmm15,%xmm2
movlhps %xmm8,%xmm2
movaps %xmm12,%xmm1
unpcklps %xmm3,%xmm1
shufps $0x24,%xmm2,%xmm1
movaps %xmm10,%xmm2
unpcklps %xmm5,%xmm2
movaps %xmm0,%xmm14
shufps $0x11,%xmm9,%xmm14
shufps $0xe2,%xmm2,%xmm14
movaps %xmm8,%xmm2
unpcklps %xmm15,%xmm2
movaps %xmm3,%xmm7
shufps $0x11,%xmm12,%xmm7
shufps $0xe2,%xmm2,%xmm7
unpckhpd %xmm10,%xmm5
unpckhps %xmm0,%xmm9
shufps $0x24,%xmm5,%xmm9
movaps %xmm15,%xmm0
unpckhpd %xmm8,%xmm0
movaps %xmm12,%xmm2
unpckhps %xmm3,%xmm2
shufps $0x24,%xmm0,%xmm2
unpckhps %xmm15,%xmm8
shufps $0x33,%xmm12,%xmm3
shufps $0xe2,%xmm8,%xmm3
movaps %xmm3,0x60(%rsp)
movaps %xmm2,0x40(%rsp)
movaps %xmm9,0x50(%rsp)
movaps %xmm7,0x20(%rsp)
movaps %xmm14,0x30(%rsp)
movaps %xmm1,(%rsp)
movaps %xmm6,0x10(%rsp)
movaps %xmm13,0x70(%rsp)
movaps -0x80(%rsp),%xmm15
movaps -0x70(%rsp),%xmm8
movaps -0x60(%rsp),%xmm0
movaps %xmm15,%xmm1
addps  %xmm3,%xmm1
subps  %xmm3,%xmm15
movaps %xmm0,%xmm6
addps  %xmm2,%xmm6
subps  %xmm2,%xmm0
movaps -0x40(%rsp),%xmm2
movaps %xmm2,%xmm11
addps  %xmm7,%xmm11
subps  %xmm7,%xmm2
movaps -0x20(%rsp),%xmm7
movaps (%rsp),%xmm10
movaps %xmm7,%xmm3
addps  %xmm10,%xmm3
subps  %xmm10,%xmm7
movaps %xmm1,%xmm4
addps  %xmm3,%xmm4
subps  %xmm3,%xmm1
movaps %xmm6,%xmm3
addps  %xmm11,%xmm3
subps  %xmm11,%xmm6
movaps %xmm3,%xmm5
addps  %xmm4,%xmm5
movaps -0x50(%rsp),%xmm10
movaps 0x10(%rsp),%xmm12
movaps 0x70(%rsp),%xmm13
movaps %xmm5,-0x80(%rsp)
subps  %xmm3,%xmm4
movaps %xmm4,(%rsp)
addps  %xmm1,%xmm6
movaps 0x8b1(%rip),%xmm4
mulps  %xmm4,%xmm6
movaps %xmm1,%xmm3
addps  %xmm6,%xmm3
movaps %xmm3,-0x40(%rsp)
subps  %xmm6,%xmm1
movaps %xmm1,0x40(%rsp)
addps  %xmm2,%xmm7
addps  %xmm0,%xmm2
addps  %xmm15,%xmm0
movaps %xmm7,%xmm1
subps  %xmm0,%xmm1
movaps 0x893(%rip),%xmm11
mulps  %xmm11,%xmm1
movaps 0x898(%rip),%xmm3
mulps  %xmm3,%xmm7
addps  %xmm1,%xmm7
movaps 0x89b(%rip),%xmm3
mulps  %xmm3,%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
movaps %xmm4,%xmm11
movaps %xmm15,%xmm1
addps  %xmm2,%xmm1
subps  %xmm2,%xmm15
movaps %xmm15,%xmm2
addps  %xmm7,%xmm2
movaps %xmm2,0x20(%rsp)
subps  %xmm7,%xmm15
movaps %xmm15,-0x20(%rsp)
movaps %xmm1,%xmm2
addps  %xmm0,%xmm2
movaps %xmm2,-0x60(%rsp)
subps  %xmm0,%xmm1
movaps %xmm1,0x60(%rsp)
movaps %xmm8,%xmm2
addps  %xmm13,%xmm2
subps  %xmm13,%xmm8
movaps %xmm10,%xmm3
addps  %xmm9,%xmm3
subps  %xmm9,%xmm10
movaps -0x30(%rsp),%xmm1
movaps %xmm1,%xmm4
addps  %xmm14,%xmm4
subps  %xmm14,%xmm1
movaps -0x10(%rsp),%xmm0
movaps %xmm0,%xmm5
addps  %xmm12,%xmm5
subps  %xmm12,%xmm0
movaps %xmm2,%xmm6
addps  %xmm5,%xmm6
subps  %xmm5,%xmm2
movaps %xmm3,%xmm5
addps  %xmm4,%xmm5
subps  %xmm4,%xmm3
movaps %xmm5,%xmm4
addps  %xmm6,%xmm4
movaps %xmm4,-0x70(%rsp)
subps  %xmm5,%xmm6
movaps %xmm6,0x10(%rsp)
addps  %xmm2,%xmm3
mulps  %xmm11,%xmm3
movaps %xmm2,%xmm4
addps  %xmm3,%xmm4
movaps %xmm4,-0x30(%rsp)
subps  %xmm3,%xmm2
movaps %xmm2,0x50(%rsp)
addps  %xmm1,%xmm0
addps  %xmm10,%xmm1
addps  %xmm8,%xmm10
movaps %xmm0,%xmm2
subps  %xmm10,%xmm2
mulps  0x7aa(%rip),%xmm2
mulps  0x7b3(%rip),%xmm0
mulps  0x7bb(%rip),%xmm10
addps  %xmm2,%xmm0
addps  %xmm2,%xmm10
mulps  %xmm11,%xmm1
movaps %xmm8,%xmm2
addps  %xmm1,%xmm2
subps  %xmm1,%xmm8
movaps %xmm8,%xmm1
addps  %xmm0,%xmm1
movaps %xmm1,0x30(%rsp)
subps  %xmm0,%xmm8
movaps %xmm8,-0x10(%rsp)
movaps %xmm2,%xmm0
addps  %xmm10,%xmm0
movaps %xmm0,-0x50(%rsp)
subps  %xmm10,%xmm2
movaps %xmm2,0x70(%rsp)
movups (%rsi),%xmm0
mulps  -0x80(%rsp),%xmm0
cvtps2pd %xmm0,%xmm1
movhlps %xmm0,%xmm0
cvtps2pd %xmm0,%xmm2
movapd 0x771(%rip),%xmm0
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm3
cvttpd2dq %xmm2,%xmm1
unpcklpd %xmm1,%xmm3
packssdw %xmm3,%xmm3
movdqa 0x761(%rip),%xmm1
paddw  %xmm1,%xmm3
movq   %xmm3,(%rdx)
movups 0x10(%rsi),%xmm2
mulps  -0x70(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x8(%rdx)
movups 0x20(%rsi),%xmm2
mulps  -0x60(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x10(%rdx)
movups 0x30(%rsi),%xmm2
mulps  -0x50(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x18(%rdx)
movups 0x40(%rsi),%xmm2
mulps  -0x40(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x20(%rdx)
movups 0x50(%rsi),%xmm2
mulps  -0x30(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x28(%rdx)
movups 0x60(%rsi),%xmm2
mulps  -0x20(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x30(%rdx)
movups 0x70(%rsi),%xmm2
mulps  -0x10(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x38(%rdx)
movups 0x80(%rsi),%xmm2
mulps  (%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x40(%rdx)
movups 0x90(%rsi),%xmm2
mulps  0x10(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x48(%rdx)
movups 0xa0(%rsi),%xmm2
mulps  0x20(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x50(%rdx)
movups 0xb0(%rsi),%xmm2
mulps  0x30(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x58(%rdx)
movups 0xc0(%rsi),%xmm2
mulps  0x40(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x60(%rdx)
movups 0xd0(%rsi),%xmm2
mulps  0x50(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x68(%rdx)
movups 0xe0(%rsi),%xmm2
mulps  0x60(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
packssdw %xmm3,%xmm3
paddw  %xmm1,%xmm3
movq   %xmm3,0x70(%rdx)
movups 0xf0(%rsi),%xmm2
mulps  0x70(%rsp),%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm0,%xmm3
cvttpd2dq %xmm3,%xmm0
cvttpd2dq %xmm2,%xmm2
unpcklpd %xmm2,%xmm0
packssdw %xmm0,%xmm0
paddw  %xmm1,%xmm0
movq   %xmm0,0x78(%rdx)
add    $0xa8,%rsp
ret

LLVM IR (-O0):
define void @fdct_and_quantization(i8* %0, float* %1, i16* %2) {
%4 = alloca i8*
%5 = alloca float*
%6 = alloca i16*
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float*
%27 = alloca [64 x float]
%28 = alloca float
%29 = alloca i8
%30 = alloca i8
store i8* %0, i8** %4
store float* %1, float** %5
store i16* %2, i16** %6
store i8 0, i8* %30
br label %31
31: ; preds = %45, %3
%32 = load i8, i8* %30
%33 = zext i8 %32 to i32
%34 = icmp slt i32 %33, 64
br i1 %34, label %35, label %48
35: ; preds = %31
%36 = load i8*, i8** %4
%37 = load i8, i8* %30
%38 = zext i8 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
%40 = load i8, i8* %39
%41 = sitofp i8 %40 to float
%42 = load i8, i8* %30
%43 = zext i8 %42 to i64
%44 = getelementptr inbounds [64 x float], [64 x float]* %27, i64 0, i64 %43
store float %41, float* %44
br label %45
45: ; preds = %35
%46 = load i8, i8* %30
%47 = add i8 %46, 1
store i8 %47, i8* %30
br label %31
48: ; preds = %31
%49 = getelementptr inbounds [64 x float], [64 x float]* %27, i64 0, i64 0
store float* %49, float** %26
store i8 7, i8* %29
br label %50
50: ; preds = %196, %48
%51 = load i8, i8* %29
%52 = sext i8 %51 to i32
%53 = icmp sge i32 %52, 0
br i1 %53, label %54, label %199
54: ; preds = %50
%55 = load float*, float** %26
%56 = getelementptr inbounds float, float* %55, i64 0
%57 = load float, float* %56
%58 = load float*, float** %26
%59 = getelementptr inbounds float, float* %58, i64 7
%60 = load float, float* %59
%61 = fadd float %57, %60
store float %61, float* %7
%62 = load float*, float** %26
%63 = getelementptr inbounds float, float* %62, i64 0
%64 = load float, float* %63
%65 = load float*, float** %26
%66 = getelementptr inbounds float, float* %65, i64 7
%67 = load float, float* %66
%68 = fsub float %64, %67
store float %68, float* %14
%69 = load float*, float** %26
%70 = getelementptr inbounds float, float* %69, i64 1
%71 = load float, float* %70
%72 = load float*, float** %26
%73 = getelementptr inbounds float, float* %72, i64 6
%74 = load float, float* %73
%75 = fadd float %71, %74
store float %75, float* %8
%76 = load float*, float** %26
%77 = getelementptr inbounds float, float* %76, i64 1
%78 = load float, float* %77
%79 = load float*, float** %26
%80 = getelementptr inbounds float, float* %79, i64 6
%81 = load float, float* %80
%82 = fsub float %78, %81
store float %82, float* %13
%83 = load float*, float** %26
%84 = getelementptr inbounds float, float* %83, i64 2
%85 = load float, float* %84
%86 = load float*, float** %26
%87 = getelementptr inbounds float, float* %86, i64 5
%88 = load float, float* %87
%89 = fadd float %85, %88
store float %89, float* %9
%90 = load float*, float** %26
%91 = getelementptr inbounds float, float* %90, i64 2
%92 = load float, float* %91
%93 = load float*, float** %26
%94 = getelementptr inbounds float, float* %93, i64 5
%95 = load float, float* %94
%96 = fsub float %92, %95
store float %96, float* %12
%97 = load float*, float** %26
%98 = getelementptr inbounds float, float* %97, i64 3
%99 = load float, float* %98
%100 = load float*, float** %26
%101 = getelementptr inbounds float, float* %100, i64 4
%102 = load float, float* %101
%103 = fadd float %99, %102
store float %103, float* %10
%104 = load float*, float** %26
%105 = getelementptr inbounds float, float* %104, i64 3
%106 = load float, float* %105
%107 = load float*, float** %26
%108 = getelementptr inbounds float, float* %107, i64 4
%109 = load float, float* %108
%110 = fsub float %106, %109
store float %110, float* %11
%111 = load float, float* %7
%112 = load float, float* %10
%113 = fadd float %111, %112
store float %113, float* %15
%114 = load float, float* %7
%115 = load float, float* %10
%116 = fsub float %114, %115
store float %116, float* %18
%117 = load float, float* %8
%118 = load float, float* %9
%119 = fadd float %117, %118
store float %119, float* %16
%120 = load float, float* %8
%121 = load float, float* %9
%122 = fsub float %120, %121
store float %122, float* %17
%123 = load float, float* %15
%124 = load float, float* %16
%125 = fadd float %123, %124
%126 = load float*, float** %26
%127 = getelementptr inbounds float, float* %126, i64 0
store float %125, float* %127
%128 = load float, float* %15
%129 = load float, float* %16
%130 = fsub float %128, %129
%131 = load float*, float** %26
%132 = getelementptr inbounds float, float* %131, i64 4
store float %130, float* %132
%133 = load float, float* %17
%134 = load float, float* %18
%135 = fadd float %133, %134
%136 = fmul float %135, 0x3FE6A09E60000000
store float %136, float* %19
%137 = load float, float* %18
%138 = load float, float* %19
%139 = fadd float %137, %138
%140 = load float*, float** %26
%141 = getelementptr inbounds float, float* %140, i64 2
store float %139, float* %141
%142 = load float, float* %18
%143 = load float, float* %19
%144 = fsub float %142, %143
%145 = load float*, float** %26
%146 = getelementptr inbounds float, float* %145, i64 6
store float %144, float* %146
%147 = load float, float* %11
%148 = load float, float* %12
%149 = fadd float %147, %148
store float %149, float* %15
%150 = load float, float* %12
%151 = load float, float* %13
%152 = fadd float %150, %151
store float %152, float* %16
%153 = load float, float* %13
%154 = load float, float* %14
%155 = fadd float %153, %154
store float %155, float* %17
%156 = load float, float* %15
%157 = load float, float* %17
%158 = fsub float %156, %157
%159 = fmul float %158, 0x3FD87DE2A0000000
store float %159, float* %23
%160 = load float, float* %15
%161 = load float, float* %23
%162 = call float @llvm.fmuladd.f32(float 0x3FE1517A80000000, float %160, float %161)
store float %162, float* %20
%163 = load float, float* %17
%164 = load float, float* %23
%165 = call float @llvm.fmuladd.f32(float 0x3FF4E7AEA0000000, float %163, float %164)
store float %165, float* %22
%166 = load float, float* %16
%167 = fmul float %166, 0x3FE6A09E60000000
store float %167, float* %21
%168 = load float, float* %14
%169 = load float, float* %21
%170 = fadd float %168, %169
store float %170, float* %24
%171 = load float, float* %14
%172 = load float, float* %21
%173 = fsub float %171, %172
store float %173, float* %25
%174 = load float, float* %25
%175 = load float, float* %20
%176 = fadd float %174, %175
%177 = load float*, float** %26
%178 = getelementptr inbounds float, float* %177, i64 5
store float %176, float* %178
%179 = load float, float* %25
%180 = load float, float* %20
%181 = fsub float %179, %180
%182 = load float*, float** %26
%183 = getelementptr inbounds float, float* %182, i64 3
store float %181, float* %183
%184 = load float, float* %24
%185 = load float, float* %22
%186 = fadd float %184, %185
%187 = load float*, float** %26
%188 = getelementptr inbounds float, float* %187, i64 1
store float %186, float* %188
%189 = load float, float* %24
%190 = load float, float* %22
%191 = fsub float %189, %190
%192 = load float*, float** %26
%193 = getelementptr inbounds float, float* %192, i64 7
store float %191, float* %193
%194 = load float*, float** %26
%195 = getelementptr inbounds float, float* %194, i64 8
store float* %195, float** %26
br label %196
196: ; preds = %54
%197 = load i8, i8* %29
%198 = add i8 %197, -1
store i8 %198, i8* %29
br label %50
199: ; preds = %50
%200 = getelementptr inbounds [64 x float], [64 x float]* %27, i64 0, i64 0
store float* %200, float** %26
store i8 7, i8* %29
br label %201
201: ; preds = %347, %199
%202 = load i8, i8* %29
%203 = sext i8 %202 to i32
%204 = icmp sge i32 %203, 0
br i1 %204, label %205, label %350
205: ; preds = %201
%206 = load float*, float** %26
%207 = getelementptr inbounds float, float* %206, i64 0
%208 = load float, float* %207
%209 = load float*, float** %26
%210 = getelementptr inbounds float, float* %209, i64 56
%211 = load float, float* %210
%212 = fadd float %208, %211
store float %212, float* %7
%213 = load float*, float** %26
%214 = getelementptr inbounds float, float* %213, i64 0
%215 = load float, float* %214
%216 = load float*, float** %26
%217 = getelementptr inbounds float, float* %216, i64 56
%218 = load float, float* %217
%219 = fsub float %215, %218
store float %219, float* %14
%220 = load float*, float** %26
%221 = getelementptr inbounds float, float* %220, i64 8
%222 = load float, float* %221
%223 = load float*, float** %26
%224 = getelementptr inbounds float, float* %223, i64 48
%225 = load float, float* %224
%226 = fadd float %222, %225
store float %226, float* %8
%227 = load float*, float** %26
%228 = getelementptr inbounds float, float* %227, i64 8
%229 = load float, float* %228
%230 = load float*, float** %26
%231 = getelementptr inbounds float, float* %230, i64 48
%232 = load float, float* %231
%233 = fsub float %229, %232
store float %233, float* %13
%234 = load float*, float** %26
%235 = getelementptr inbounds float, float* %234, i64 16
%236 = load float, float* %235
%237 = load float*, float** %26
%238 = getelementptr inbounds float, float* %237, i64 40
%239 = load float, float* %238
%240 = fadd float %236, %239
store float %240, float* %9
%241 = load float*, float** %26
%242 = getelementptr inbounds float, float* %241, i64 16
%243 = load float, float* %242
%244 = load float*, float** %26
%245 = getelementptr inbounds float, float* %244, i64 40
%246 = load float, float* %245
%247 = fsub float %243, %246
store float %247, float* %12
%248 = load float*, float** %26
%249 = getelementptr inbounds float, float* %248, i64 24
%250 = load float, float* %249
%251 = load float*, float** %26
%252 = getelementptr inbounds float, float* %251, i64 32
%253 = load float, float* %252
%254 = fadd float %250, %253
store float %254, float* %10
%255 = load float*, float** %26
%256 = getelementptr inbounds float, float* %255, i64 24
%257 = load float, float* %256
%258 = load float*, float** %26
%259 = getelementptr inbounds float, float* %258, i64 32
%260 = load float, float* %259
%261 = fsub float %257, %260
store float %261, float* %11
%262 = load float, float* %7
%263 = load float, float* %10
%264 = fadd float %262, %263
store float %264, float* %15
%265 = load float, float* %7
%266 = load float, float* %10
%267 = fsub float %265, %266
store float %267, float* %18
%268 = load float, float* %8
%269 = load float, float* %9
%270 = fadd float %268, %269
store float %270, float* %16
%271 = load float, float* %8
%272 = load float, float* %9
%273 = fsub float %271, %272
store float %273, float* %17
%274 = load float, float* %15
%275 = load float, float* %16
%276 = fadd float %274, %275
%277 = load float*, float** %26
%278 = getelementptr inbounds float, float* %277, i64 0
store float %276, float* %278
%279 = load float, float* %15
%280 = load float, float* %16
%281 = fsub float %279, %280
%282 = load float*, float** %26
%283 = getelementptr inbounds float, float* %282, i64 32
store float %281, float* %283
%284 = load float, float* %17
%285 = load float, float* %18
%286 = fadd float %284, %285
%287 = fmul float %286, 0x3FE6A09E60000000
store float %287, float* %19
%288 = load float, float* %18
%289 = load float, float* %19
%290 = fadd float %288, %289
%291 = load float*, float** %26
%292 = getelementptr inbounds float, float* %291, i64 16
store float %290, float* %292
%293 = load float, float* %18
%294 = load float, float* %19
%295 = fsub float %293, %294
%296 = load float*, float** %26
%297 = getelementptr inbounds float, float* %296, i64 48
store float %295, float* %297
%298 = load float, float* %11
%299 = load float, float* %12
%300 = fadd float %298, %299
store float %300, float* %15
%301 = load float, float* %12
%302 = load float, float* %13
%303 = fadd float %301, %302
store float %303, float* %16
%304 = load float, float* %13
%305 = load float, float* %14
%306 = fadd float %304, %305
store float %306, float* %17
%307 = load float, float* %15
%308 = load float, float* %17
%309 = fsub float %307, %308
%310 = fmul float %309, 0x3FD87DE2A0000000
store float %310, float* %23
%311 = load float, float* %15
%312 = load float, float* %23
%313 = call float @llvm.fmuladd.f32(float 0x3FE1517A80000000, float %311, float %312)
store float %313, float* %20
%314 = load float, float* %17
%315 = load float, float* %23
%316 = call float @llvm.fmuladd.f32(float 0x3FF4E7AEA0000000, float %314, float %315)
store float %316, float* %22
%317 = load float, float* %16
%318 = fmul float %317, 0x3FE6A09E60000000
store float %318, float* %21
%319 = load float, float* %14
%320 = load float, float* %21
%321 = fadd float %319, %320
store float %321, float* %24
%322 = load float, float* %14
%323 = load float, float* %21
%324 = fsub float %322, %323
store float %324, float* %25
%325 = load float, float* %25
%326 = load float, float* %20
%327 = fadd float %325, %326
%328 = load float*, float** %26
%329 = getelementptr inbounds float, float* %328, i64 40
store float %327, float* %329
%330 = load float, float* %25
%331 = load float, float* %20
%332 = fsub float %330, %331
%333 = load float*, float** %26
%334 = getelementptr inbounds float, float* %333, i64 24
store float %332, float* %334
%335 = load float, float* %24
%336 = load float, float* %22
%337 = fadd float %335, %336
%338 = load float*, float** %26
%339 = getelementptr inbounds float, float* %338, i64 8
store float %337, float* %339
%340 = load float, float* %24
%341 = load float, float* %22
%342 = fsub float %340, %341
%343 = load float*, float** %26
%344 = getelementptr inbounds float, float* %343, i64 56
store float %342, float* %344
%345 = load float*, float** %26
%346 = getelementptr inbounds float, float* %345, i32 1
store float* %346, float** %26
br label %347
347: ; preds = %205
%348 = load i8, i8* %29
%349 = add i8 %348, -1
store i8 %349, i8* %29
br label %201
350: ; preds = %201
store i8 0, i8* %30
br label %351
351: ; preds = %377, %350
%352 = load i8, i8* %30
%353 = zext i8 %352 to i32
%354 = icmp slt i32 %353, 64
br i1 %354, label %355, label %380
355: ; preds = %351
%356 = load i8, i8* %30
%357 = zext i8 %356 to i64
%358 = getelementptr inbounds [64 x float], [64 x float]* %27, i64 0, i64 %357
%359 = load float, float* %358
%360 = load float*, float** %5
%361 = load i8, i8* %30
%362 = zext i8 %361 to i64
%363 = getelementptr inbounds float, float* %360, i64 %362
%364 = load float, float* %363
%365 = fmul float %359, %364
store float %365, float* %28
%366 = load float, float* %28
%367 = fpext float %366 to double
%368 = fadd double %367, 1.638450e+04
%369 = fptosi double %368 to i16
%370 = sext i16 %369 to i32
%371 = sub nsw i32 %370, 16384
%372 = trunc i32 %371 to i16
%373 = load i16*, i16** %6
%374 = load i8, i8* %30
%375 = zext i8 %374 to i64
%376 = getelementptr inbounds i16, i16* %373, i64 %375
store i16 %372, i16* %376
br label %377
377: ; preds = %355
%378 = load i8, i8* %30
%379 = add i8 %378, 1
store i8 %379, i8* %30
br label %351
380: ; preds = %351
ret void
}

LLVM IR (-O2):
define void @fdct_and_quantization(i8* nocapture %0, float* nocapture %1, i16* nocapture writeonly %2) {
%4 = alloca [64 x float]
%5 = bitcast [64 x float]* %4 to i8*
%6 = bitcast i8* %0 to <4 x i8>*
%7 = load <4 x i8>, <4 x i8>* %6
%8 = sitofp <4 x i8> %7 to <4 x float>
%9 = bitcast [64 x float]* %4 to <4 x float>*
store <4 x float> %8, <4 x float>* %9
%10 = getelementptr inbounds i8, i8* %0, i64 4
%11 = bitcast i8* %10 to <4 x i8>*
%12 = load <4 x i8>, <4 x i8>* %11
%13 = sitofp <4 x i8> %12 to <4 x float>
%14 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 4
%15 = bitcast float* %14 to <4 x float>*
store <4 x float> %13, <4 x float>* %15
%16 = getelementptr inbounds i8, i8* %0, i64 8
%17 = bitcast i8* %16 to <4 x i8>*
%18 = load <4 x i8>, <4 x i8>* %17
%19 = sitofp <4 x i8> %18 to <4 x float>
%20 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 8
%21 = bitcast float* %20 to <4 x float>*
store <4 x float> %19, <4 x float>* %21
%22 = getelementptr inbounds i8, i8* %0, i64 12
%23 = bitcast i8* %22 to <4 x i8>*
%24 = load <4 x i8>, <4 x i8>* %23
%25 = sitofp <4 x i8> %24 to <4 x float>
%26 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 12
%27 = bitcast float* %26 to <4 x float>*
store <4 x float> %25, <4 x float>* %27
%28 = getelementptr inbounds i8, i8* %0, i64 16
%29 = bitcast i8* %28 to <4 x i8>*
%30 = load <4 x i8>, <4 x i8>* %29
%31 = sitofp <4 x i8> %30 to <4 x float>
%32 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 16
%33 = bitcast float* %32 to <4 x float>*
store <4 x float> %31, <4 x float>* %33
%34 = getelementptr inbounds i8, i8* %0, i64 20
%35 = bitcast i8* %34 to <4 x i8>*
%36 = load <4 x i8>, <4 x i8>* %35
%37 = sitofp <4 x i8> %36 to <4 x float>
%38 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 20
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %37, <4 x float>* %39
%40 = getelementptr inbounds i8, i8* %0, i64 24
%41 = bitcast i8* %40 to <4 x i8>*
%42 = load <4 x i8>, <4 x i8>* %41
%43 = sitofp <4 x i8> %42 to <4 x float>
%44 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 24
%45 = bitcast float* %44 to <4 x float>*
store <4 x float> %43, <4 x float>* %45
%46 = getelementptr inbounds i8, i8* %0, i64 28
%47 = bitcast i8* %46 to <4 x i8>*
%48 = load <4 x i8>, <4 x i8>* %47
%49 = sitofp <4 x i8> %48 to <4 x float>
%50 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 28
%51 = bitcast float* %50 to <4 x float>*
store <4 x float> %49, <4 x float>* %51
%52 = getelementptr inbounds i8, i8* %0, i64 32
%53 = bitcast i8* %52 to <4 x i8>*
%54 = load <4 x i8>, <4 x i8>* %53
%55 = sitofp <4 x i8> %54 to <4 x float>
%56 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 32
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %55, <4 x float>* %57
%58 = getelementptr inbounds i8, i8* %0, i64 36
%59 = bitcast i8* %58 to <4 x i8>*
%60 = load <4 x i8>, <4 x i8>* %59
%61 = sitofp <4 x i8> %60 to <4 x float>
%62 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 36
%63 = bitcast float* %62 to <4 x float>*
store <4 x float> %61, <4 x float>* %63
%64 = getelementptr inbounds i8, i8* %0, i64 40
%65 = bitcast i8* %64 to <4 x i8>*
%66 = load <4 x i8>, <4 x i8>* %65
%67 = sitofp <4 x i8> %66 to <4 x float>
%68 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 40
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> %67, <4 x float>* %69
%70 = getelementptr inbounds i8, i8* %0, i64 44
%71 = bitcast i8* %70 to <4 x i8>*
%72 = load <4 x i8>, <4 x i8>* %71
%73 = sitofp <4 x i8> %72 to <4 x float>
%74 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 44
%75 = bitcast float* %74 to <4 x float>*
store <4 x float> %73, <4 x float>* %75
%76 = getelementptr inbounds i8, i8* %0, i64 48
%77 = bitcast i8* %76 to <4 x i8>*
%78 = load <4 x i8>, <4 x i8>* %77
%79 = sitofp <4 x i8> %78 to <4 x float>
%80 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 48
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> %79, <4 x float>* %81
%82 = getelementptr inbounds i8, i8* %0, i64 52
%83 = bitcast i8* %82 to <4 x i8>*
%84 = load <4 x i8>, <4 x i8>* %83
%85 = sitofp <4 x i8> %84 to <4 x float>
%86 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 52
%87 = bitcast float* %86 to <4 x float>*
store <4 x float> %85, <4 x float>* %87
%88 = getelementptr inbounds i8, i8* %0, i64 56
%89 = bitcast i8* %88 to <4 x i8>*
%90 = load <4 x i8>, <4 x i8>* %89
%91 = sitofp <4 x i8> %90 to <4 x float>
%92 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 56
%93 = bitcast float* %92 to <4 x float>*
store <4 x float> %91, <4 x float>* %93
%94 = getelementptr inbounds i8, i8* %0, i64 60
%95 = bitcast i8* %94 to <4 x i8>*
%96 = load <4 x i8>, <4 x i8>* %95
%97 = sitofp <4 x i8> %96 to <4 x float>
%98 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 60
%99 = bitcast float* %98 to <4 x float>*
store <4 x float> %97, <4 x float>* %99
%100 = bitcast [64 x float]* %4 to <32 x float>*
%101 = load <32 x float>, <32 x float>* %100
%102 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 0, i32 8, i32 16, i32 24>
%103 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 1, i32 9, i32 17, i32 25>
%104 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 2, i32 10, i32 18, i32 26>
%105 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 3, i32 11, i32 19, i32 27>
%106 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 4, i32 12, i32 20, i32 28>
%107 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 5, i32 13, i32 21, i32 29>
%108 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 6, i32 14, i32 22, i32 30>
%109 = shufflevector <32 x float> %101, <32 x float> poison, <4 x i32> <i32 7, i32 15, i32 23, i32 31>
%110 = fadd <4 x float> %102, %109
%111 = fsub <4 x float> %102, %109
%112 = fadd <4 x float> %103, %108
%113 = fsub <4 x float> %103, %108
%114 = fadd <4 x float> %104, %107
%115 = fsub <4 x float> %104, %107
%116 = fadd <4 x float> %105, %106
%117 = fsub <4 x float> %105, %106
%118 = fadd <4 x float> %110, %116
%119 = fsub <4 x float> %110, %116
%120 = fadd <4 x float> %112, %114
%121 = fsub <4 x float> %112, %114
%122 = fadd <4 x float> %120, %118
%123 = fsub <4 x float> %118, %120
%124 = fadd <4 x float> %121, %119
%125 = fmul <4 x float> %124, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%126 = fadd <4 x float> %119, %125
%127 = fsub <4 x float> %119, %125
%128 = fadd <4 x float> %115, %117
%129 = fadd <4 x float> %113, %115
%130 = fadd <4 x float> %111, %113
%131 = fsub <4 x float> %128, %130
%132 = fmul <4 x float> %131, <float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000>
%133 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %128, <4 x float> <float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000>, <4 x float> %132)
%134 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %130, <4 x float> <float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000>, <4 x float> %132)
%135 = fmul <4 x float> %129, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%136 = fadd <4 x float> %111, %135
%137 = fsub <4 x float> %111, %135
%138 = fadd <4 x float> %137, %133
%139 = fsub <4 x float> %137, %133
%140 = fadd <4 x float> %136, %134
%141 = fsub <4 x float> %136, %134
%142 = bitcast [64 x float]* %4 to <32 x float>*
%143 = shufflevector <4 x float> %122, <4 x float> %140, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%144 = shufflevector <4 x float> %126, <4 x float> %139, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%145 = shufflevector <4 x float> %123, <4 x float> %138, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%146 = shufflevector <4 x float> %127, <4 x float> %141, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%147 = shufflevector <8 x float> %143, <8 x float> %144, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%148 = shufflevector <8 x float> %145, <8 x float> %146, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%149 = shufflevector <16 x float> %147, <16 x float> %148, <32 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28, i32 1, i32 5, i32 9, i32 13, i32 17, i32 21, i32 25, i32 29, i32 2, i32 6, i32 10, i32 14, i32 18, i32 22, i32 26, i32 30, i32 3, i32 7, i32 11, i32 15, i32 19, i32 23, i32 27, i32 31>
store <32 x float> %149, <32 x float>* %142
%150 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 32
%151 = bitcast float* %150 to <32 x float>*
%152 = load <32 x float>, <32 x float>* %151
%153 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 0, i32 8, i32 16, i32 24>
%154 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 1, i32 9, i32 17, i32 25>
%155 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 2, i32 10, i32 18, i32 26>
%156 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 3, i32 11, i32 19, i32 27>
%157 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 4, i32 12, i32 20, i32 28>
%158 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 5, i32 13, i32 21, i32 29>
%159 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 6, i32 14, i32 22, i32 30>
%160 = shufflevector <32 x float> %152, <32 x float> poison, <4 x i32> <i32 7, i32 15, i32 23, i32 31>
%161 = fadd <4 x float> %153, %160
%162 = fsub <4 x float> %153, %160
%163 = fadd <4 x float> %154, %159
%164 = fsub <4 x float> %154, %159
%165 = fadd <4 x float> %155, %158
%166 = fsub <4 x float> %155, %158
%167 = fadd <4 x float> %156, %157
%168 = fsub <4 x float> %156, %157
%169 = fadd <4 x float> %161, %167
%170 = fsub <4 x float> %161, %167
%171 = fadd <4 x float> %163, %165
%172 = fsub <4 x float> %163, %165
%173 = fadd <4 x float> %171, %169
%174 = fsub <4 x float> %169, %171
%175 = fadd <4 x float> %172, %170
%176 = fmul <4 x float> %175, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%177 = fadd <4 x float> %170, %176
%178 = fsub <4 x float> %170, %176
%179 = fadd <4 x float> %166, %168
%180 = fadd <4 x float> %164, %166
%181 = fadd <4 x float> %162, %164
%182 = fsub <4 x float> %179, %181
%183 = fmul <4 x float> %182, <float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000>
%184 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %179, <4 x float> <float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000>, <4 x float> %183)
%185 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %181, <4 x float> <float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000>, <4 x float> %183)
%186 = fmul <4 x float> %180, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%187 = fadd <4 x float> %162, %186
%188 = fsub <4 x float> %162, %186
%189 = fadd <4 x float> %188, %184
%190 = fsub <4 x float> %188, %184
%191 = fadd <4 x float> %187, %185
%192 = fsub <4 x float> %187, %185
%193 = bitcast float* %150 to <32 x float>*
%194 = shufflevector <4 x float> %173, <4 x float> %191, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%195 = shufflevector <4 x float> %177, <4 x float> %190, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%196 = shufflevector <4 x float> %174, <4 x float> %189, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%197 = shufflevector <4 x float> %178, <4 x float> %192, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%198 = shufflevector <8 x float> %194, <8 x float> %195, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%199 = shufflevector <8 x float> %196, <8 x float> %197, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%200 = shufflevector <16 x float> %198, <16 x float> %199, <32 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28, i32 1, i32 5, i32 9, i32 13, i32 17, i32 21, i32 25, i32 29, i32 2, i32 6, i32 10, i32 14, i32 18, i32 22, i32 26, i32 30, i32 3, i32 7, i32 11, i32 15, i32 19, i32 23, i32 27, i32 31>
store <32 x float> %200, <32 x float>* %193
%201 = bitcast [64 x float]* %4 to <4 x float>*
%202 = load <4 x float>, <4 x float>* %201
%203 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 56
%204 = bitcast float* %203 to <4 x float>*
%205 = load <4 x float>, <4 x float>* %204
%206 = fadd <4 x float> %202, %205
%207 = fsub <4 x float> %202, %205
%208 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 8
%209 = bitcast float* %208 to <4 x float>*
%210 = load <4 x float>, <4 x float>* %209
%211 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 48
%212 = bitcast float* %211 to <4 x float>*
%213 = load <4 x float>, <4 x float>* %212
%214 = fadd <4 x float> %210, %213
%215 = fsub <4 x float> %210, %213
%216 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 16
%217 = bitcast float* %216 to <4 x float>*
%218 = load <4 x float>, <4 x float>* %217
%219 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 40
%220 = bitcast float* %219 to <4 x float>*
%221 = load <4 x float>, <4 x float>* %220
%222 = fadd <4 x float> %218, %221
%223 = fsub <4 x float> %218, %221
%224 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 24
%225 = bitcast float* %224 to <4 x float>*
%226 = load <4 x float>, <4 x float>* %225
%227 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 32
%228 = bitcast float* %227 to <4 x float>*
%229 = load <4 x float>, <4 x float>* %228
%230 = fadd <4 x float> %226, %229
%231 = fsub <4 x float> %226, %229
%232 = fadd <4 x float> %206, %230
%233 = fsub <4 x float> %206, %230
%234 = fadd <4 x float> %214, %222
%235 = fsub <4 x float> %214, %222
%236 = fadd <4 x float> %234, %232
%237 = bitcast [64 x float]* %4 to <4 x float>*
store <4 x float> %236, <4 x float>* %237
%238 = fsub <4 x float> %232, %234
%239 = bitcast float* %227 to <4 x float>*
store <4 x float> %238, <4 x float>* %239
%240 = fadd <4 x float> %235, %233
%241 = fmul <4 x float> %240, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%242 = fadd <4 x float> %233, %241
%243 = bitcast float* %216 to <4 x float>*
store <4 x float> %242, <4 x float>* %243
%244 = fsub <4 x float> %233, %241
%245 = bitcast float* %211 to <4 x float>*
store <4 x float> %244, <4 x float>* %245
%246 = fadd <4 x float> %223, %231
%247 = fadd <4 x float> %215, %223
%248 = fadd <4 x float> %207, %215
%249 = fsub <4 x float> %246, %248
%250 = fmul <4 x float> %249, <float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000>
%251 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %246, <4 x float> <float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000>, <4 x float> %250)
%252 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %248, <4 x float> <float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000>, <4 x float> %250)
%253 = fmul <4 x float> %247, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%254 = fadd <4 x float> %207, %253
%255 = fsub <4 x float> %207, %253
%256 = fadd <4 x float> %255, %251
%257 = bitcast float* %219 to <4 x float>*
store <4 x float> %256, <4 x float>* %257
%258 = fsub <4 x float> %255, %251
%259 = bitcast float* %224 to <4 x float>*
store <4 x float> %258, <4 x float>* %259
%260 = fadd <4 x float> %254, %252
%261 = bitcast float* %208 to <4 x float>*
store <4 x float> %260, <4 x float>* %261
%262 = fsub <4 x float> %254, %252
%263 = bitcast float* %203 to <4 x float>*
store <4 x float> %262, <4 x float>* %263
%264 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 4
%265 = bitcast float* %264 to <4 x float>*
%266 = load <4 x float>, <4 x float>* %265
%267 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 60
%268 = bitcast float* %267 to <4 x float>*
%269 = load <4 x float>, <4 x float>* %268
%270 = fadd <4 x float> %266, %269
%271 = fsub <4 x float> %266, %269
%272 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 12
%273 = bitcast float* %272 to <4 x float>*
%274 = load <4 x float>, <4 x float>* %273
%275 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 52
%276 = bitcast float* %275 to <4 x float>*
%277 = load <4 x float>, <4 x float>* %276
%278 = fadd <4 x float> %274, %277
%279 = fsub <4 x float> %274, %277
%280 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 20
%281 = bitcast float* %280 to <4 x float>*
%282 = load <4 x float>, <4 x float>* %281
%283 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 44
%284 = bitcast float* %283 to <4 x float>*
%285 = load <4 x float>, <4 x float>* %284
%286 = fadd <4 x float> %282, %285
%287 = fsub <4 x float> %282, %285
%288 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 28
%289 = bitcast float* %288 to <4 x float>*
%290 = load <4 x float>, <4 x float>* %289
%291 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 36
%292 = bitcast float* %291 to <4 x float>*
%293 = load <4 x float>, <4 x float>* %292
%294 = fadd <4 x float> %290, %293
%295 = fsub <4 x float> %290, %293
%296 = fadd <4 x float> %270, %294
%297 = fsub <4 x float> %270, %294
%298 = fadd <4 x float> %278, %286
%299 = fsub <4 x float> %278, %286
%300 = fadd <4 x float> %298, %296
%301 = bitcast float* %264 to <4 x float>*
store <4 x float> %300, <4 x float>* %301
%302 = fsub <4 x float> %296, %298
%303 = bitcast float* %291 to <4 x float>*
store <4 x float> %302, <4 x float>* %303
%304 = fadd <4 x float> %299, %297
%305 = fmul <4 x float> %304, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%306 = fadd <4 x float> %297, %305
%307 = bitcast float* %280 to <4 x float>*
store <4 x float> %306, <4 x float>* %307
%308 = fsub <4 x float> %297, %305
%309 = bitcast float* %275 to <4 x float>*
store <4 x float> %308, <4 x float>* %309
%310 = fadd <4 x float> %287, %295
%311 = fadd <4 x float> %279, %287
%312 = fadd <4 x float> %271, %279
%313 = fsub <4 x float> %310, %312
%314 = fmul <4 x float> %313, <float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000, float 0x3FD87DE2A0000000>
%315 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %310, <4 x float> <float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000, float 0x3FE1517A80000000>, <4 x float> %314)
%316 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %312, <4 x float> <float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000, float 0x3FF4E7AEA0000000>, <4 x float> %314)
%317 = fmul <4 x float> %311, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%318 = fadd <4 x float> %271, %317
%319 = fsub <4 x float> %271, %317
%320 = fadd <4 x float> %319, %315
%321 = bitcast float* %283 to <4 x float>*
store <4 x float> %320, <4 x float>* %321
%322 = fsub <4 x float> %319, %315
%323 = bitcast float* %288 to <4 x float>*
store <4 x float> %322, <4 x float>* %323
%324 = fadd <4 x float> %318, %316
%325 = bitcast float* %272 to <4 x float>*
store <4 x float> %324, <4 x float>* %325
%326 = fsub <4 x float> %318, %316
%327 = bitcast float* %267 to <4 x float>*
store <4 x float> %326, <4 x float>* %327
%328 = bitcast [64 x float]* %4 to <4 x float>*
%329 = load <4 x float>, <4 x float>* %328
%330 = bitcast float* %1 to <4 x float>*
%331 = load <4 x float>, <4 x float>* %330
%332 = fmul <4 x float> %329, %331
%333 = fpext <4 x float> %332 to <4 x double>
%334 = fadd <4 x double> %333, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%335 = fptosi <4 x double> %334 to <4 x i16>
%336 = add <4 x i16> %335, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%337 = bitcast i16* %2 to <4 x i16>*
store <4 x i16> %336, <4 x i16>* %337
%338 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 4
%339 = bitcast float* %338 to <4 x float>*
%340 = load <4 x float>, <4 x float>* %339
%341 = getelementptr inbounds float, float* %1, i64 4
%342 = bitcast float* %341 to <4 x float>*
%343 = load <4 x float>, <4 x float>* %342
%344 = fmul <4 x float> %340, %343
%345 = fpext <4 x float> %344 to <4 x double>
%346 = fadd <4 x double> %345, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%347 = fptosi <4 x double> %346 to <4 x i16>
%348 = add <4 x i16> %347, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%349 = getelementptr inbounds i16, i16* %2, i64 4
%350 = bitcast i16* %349 to <4 x i16>*
store <4 x i16> %348, <4 x i16>* %350
%351 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 8
%352 = bitcast float* %351 to <4 x float>*
%353 = load <4 x float>, <4 x float>* %352
%354 = getelementptr inbounds float, float* %1, i64 8
%355 = bitcast float* %354 to <4 x float>*
%356 = load <4 x float>, <4 x float>* %355
%357 = fmul <4 x float> %353, %356
%358 = fpext <4 x float> %357 to <4 x double>
%359 = fadd <4 x double> %358, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%360 = fptosi <4 x double> %359 to <4 x i16>
%361 = add <4 x i16> %360, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%362 = getelementptr inbounds i16, i16* %2, i64 8
%363 = bitcast i16* %362 to <4 x i16>*
store <4 x i16> %361, <4 x i16>* %363
%364 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 12
%365 = bitcast float* %364 to <4 x float>*
%366 = load <4 x float>, <4 x float>* %365
%367 = getelementptr inbounds float, float* %1, i64 12
%368 = bitcast float* %367 to <4 x float>*
%369 = load <4 x float>, <4 x float>* %368
%370 = fmul <4 x float> %366, %369
%371 = fpext <4 x float> %370 to <4 x double>
%372 = fadd <4 x double> %371, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%373 = fptosi <4 x double> %372 to <4 x i16>
%374 = add <4 x i16> %373, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%375 = getelementptr inbounds i16, i16* %2, i64 12
%376 = bitcast i16* %375 to <4 x i16>*
store <4 x i16> %374, <4 x i16>* %376
%377 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 16
%378 = bitcast float* %377 to <4 x float>*
%379 = load <4 x float>, <4 x float>* %378
%380 = getelementptr inbounds float, float* %1, i64 16
%381 = bitcast float* %380 to <4 x float>*
%382 = load <4 x float>, <4 x float>* %381
%383 = fmul <4 x float> %379, %382
%384 = fpext <4 x float> %383 to <4 x double>
%385 = fadd <4 x double> %384, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%386 = fptosi <4 x double> %385 to <4 x i16>
%387 = add <4 x i16> %386, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%388 = getelementptr inbounds i16, i16* %2, i64 16
%389 = bitcast i16* %388 to <4 x i16>*
store <4 x i16> %387, <4 x i16>* %389
%390 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 20
%391 = bitcast float* %390 to <4 x float>*
%392 = load <4 x float>, <4 x float>* %391
%393 = getelementptr inbounds float, float* %1, i64 20
%394 = bitcast float* %393 to <4 x float>*
%395 = load <4 x float>, <4 x float>* %394
%396 = fmul <4 x float> %392, %395
%397 = fpext <4 x float> %396 to <4 x double>
%398 = fadd <4 x double> %397, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%399 = fptosi <4 x double> %398 to <4 x i16>
%400 = add <4 x i16> %399, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%401 = getelementptr inbounds i16, i16* %2, i64 20
%402 = bitcast i16* %401 to <4 x i16>*
store <4 x i16> %400, <4 x i16>* %402
%403 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 24
%404 = bitcast float* %403 to <4 x float>*
%405 = load <4 x float>, <4 x float>* %404
%406 = getelementptr inbounds float, float* %1, i64 24
%407 = bitcast float* %406 to <4 x float>*
%408 = load <4 x float>, <4 x float>* %407
%409 = fmul <4 x float> %405, %408
%410 = fpext <4 x float> %409 to <4 x double>
%411 = fadd <4 x double> %410, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%412 = fptosi <4 x double> %411 to <4 x i16>
%413 = add <4 x i16> %412, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%414 = getelementptr inbounds i16, i16* %2, i64 24
%415 = bitcast i16* %414 to <4 x i16>*
store <4 x i16> %413, <4 x i16>* %415
%416 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 28
%417 = bitcast float* %416 to <4 x float>*
%418 = load <4 x float>, <4 x float>* %417
%419 = getelementptr inbounds float, float* %1, i64 28
%420 = bitcast float* %419 to <4 x float>*
%421 = load <4 x float>, <4 x float>* %420
%422 = fmul <4 x float> %418, %421
%423 = fpext <4 x float> %422 to <4 x double>
%424 = fadd <4 x double> %423, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%425 = fptosi <4 x double> %424 to <4 x i16>
%426 = add <4 x i16> %425, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%427 = getelementptr inbounds i16, i16* %2, i64 28
%428 = bitcast i16* %427 to <4 x i16>*
store <4 x i16> %426, <4 x i16>* %428
%429 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 32
%430 = bitcast float* %429 to <4 x float>*
%431 = load <4 x float>, <4 x float>* %430
%432 = getelementptr inbounds float, float* %1, i64 32
%433 = bitcast float* %432 to <4 x float>*
%434 = load <4 x float>, <4 x float>* %433
%435 = fmul <4 x float> %431, %434
%436 = fpext <4 x float> %435 to <4 x double>
%437 = fadd <4 x double> %436, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%438 = fptosi <4 x double> %437 to <4 x i16>
%439 = add <4 x i16> %438, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%440 = getelementptr inbounds i16, i16* %2, i64 32
%441 = bitcast i16* %440 to <4 x i16>*
store <4 x i16> %439, <4 x i16>* %441
%442 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 36
%443 = bitcast float* %442 to <4 x float>*
%444 = load <4 x float>, <4 x float>* %443
%445 = getelementptr inbounds float, float* %1, i64 36
%446 = bitcast float* %445 to <4 x float>*
%447 = load <4 x float>, <4 x float>* %446
%448 = fmul <4 x float> %444, %447
%449 = fpext <4 x float> %448 to <4 x double>
%450 = fadd <4 x double> %449, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%451 = fptosi <4 x double> %450 to <4 x i16>
%452 = add <4 x i16> %451, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%453 = getelementptr inbounds i16, i16* %2, i64 36
%454 = bitcast i16* %453 to <4 x i16>*
store <4 x i16> %452, <4 x i16>* %454
%455 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 40
%456 = bitcast float* %455 to <4 x float>*
%457 = load <4 x float>, <4 x float>* %456
%458 = getelementptr inbounds float, float* %1, i64 40
%459 = bitcast float* %458 to <4 x float>*
%460 = load <4 x float>, <4 x float>* %459
%461 = fmul <4 x float> %457, %460
%462 = fpext <4 x float> %461 to <4 x double>
%463 = fadd <4 x double> %462, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%464 = fptosi <4 x double> %463 to <4 x i16>
%465 = add <4 x i16> %464, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%466 = getelementptr inbounds i16, i16* %2, i64 40
%467 = bitcast i16* %466 to <4 x i16>*
store <4 x i16> %465, <4 x i16>* %467
%468 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 44
%469 = bitcast float* %468 to <4 x float>*
%470 = load <4 x float>, <4 x float>* %469
%471 = getelementptr inbounds float, float* %1, i64 44
%472 = bitcast float* %471 to <4 x float>*
%473 = load <4 x float>, <4 x float>* %472
%474 = fmul <4 x float> %470, %473
%475 = fpext <4 x float> %474 to <4 x double>
%476 = fadd <4 x double> %475, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%477 = fptosi <4 x double> %476 to <4 x i16>
%478 = add <4 x i16> %477, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%479 = getelementptr inbounds i16, i16* %2, i64 44
%480 = bitcast i16* %479 to <4 x i16>*
store <4 x i16> %478, <4 x i16>* %480
%481 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 48
%482 = bitcast float* %481 to <4 x float>*
%483 = load <4 x float>, <4 x float>* %482
%484 = getelementptr inbounds float, float* %1, i64 48
%485 = bitcast float* %484 to <4 x float>*
%486 = load <4 x float>, <4 x float>* %485
%487 = fmul <4 x float> %483, %486
%488 = fpext <4 x float> %487 to <4 x double>
%489 = fadd <4 x double> %488, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%490 = fptosi <4 x double> %489 to <4 x i16>
%491 = add <4 x i16> %490, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%492 = getelementptr inbounds i16, i16* %2, i64 48
%493 = bitcast i16* %492 to <4 x i16>*
store <4 x i16> %491, <4 x i16>* %493
%494 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 52
%495 = bitcast float* %494 to <4 x float>*
%496 = load <4 x float>, <4 x float>* %495
%497 = getelementptr inbounds float, float* %1, i64 52
%498 = bitcast float* %497 to <4 x float>*
%499 = load <4 x float>, <4 x float>* %498
%500 = fmul <4 x float> %496, %499
%501 = fpext <4 x float> %500 to <4 x double>
%502 = fadd <4 x double> %501, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%503 = fptosi <4 x double> %502 to <4 x i16>
%504 = add <4 x i16> %503, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%505 = getelementptr inbounds i16, i16* %2, i64 52
%506 = bitcast i16* %505 to <4 x i16>*
store <4 x i16> %504, <4 x i16>* %506
%507 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 56
%508 = bitcast float* %507 to <4 x float>*
%509 = load <4 x float>, <4 x float>* %508
%510 = getelementptr inbounds float, float* %1, i64 56
%511 = bitcast float* %510 to <4 x float>*
%512 = load <4 x float>, <4 x float>* %511
%513 = fmul <4 x float> %509, %512
%514 = fpext <4 x float> %513 to <4 x double>
%515 = fadd <4 x double> %514, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%516 = fptosi <4 x double> %515 to <4 x i16>
%517 = add <4 x i16> %516, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%518 = getelementptr inbounds i16, i16* %2, i64 56
%519 = bitcast i16* %518 to <4 x i16>*
store <4 x i16> %517, <4 x i16>* %519
%520 = getelementptr inbounds [64 x float], [64 x float]* %4, i64 0, i64 60
%521 = bitcast float* %520 to <4 x float>*
%522 = load <4 x float>, <4 x float>* %521
%523 = getelementptr inbounds float, float* %1, i64 60
%524 = bitcast float* %523 to <4 x float>*
%525 = load <4 x float>, <4 x float>* %524
%526 = fmul <4 x float> %522, %525
%527 = fpext <4 x float> %526 to <4 x double>
%528 = fadd <4 x double> %527, <double 1.638450e+04, double 1.638450e+04, double 1.638450e+04, double 1.638450e+04>
%529 = fptosi <4 x double> %528 to <4 x i16>
%530 = add <4 x i16> %529, <i16 -16384, i16 -16384, i16 -16384, i16 -16384>
%531 = getelementptr inbounds i16, i16* %2, i64 60
%532 = bitcast i16* %531 to <4 x i16>*
store <4 x i16> %530, <4 x i16>* %532
ret void
}