double d71234distsq(double v1[7], double v2[7]) {
  double distsq;
  double dwnby;
  double dtrial[24];
  int i;
  distsq = v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3] +
           v1[4] * v1[4] + v1[5] * v1[5] + v1[6] * v1[6] + v2[0] * v2[0] +
           v2[1] * v2[1] + v2[2] * v2[2] + v2[3] * v2[3] + v2[4] * v2[4] +
           v2[5] * v2[5] + v2[6] * v2[6];
  dtrial[0] =
      2. * (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2] + v1[3] * v2[3] +
            v1[4] * v2[4] + v1[5] * v2[5] + v1[6] * v2[6]);
  dtrial[1] =
      2. * (v1[0] * v2[0] + v1[1] * v2[1] + v1[3] * v2[2] + v1[2] * v2[3] +
            v1[5] * v2[4] + v1[4] * v2[5] + v1[6] * v2[6]);
  dtrial[2] =
      2. * (v1[0] * v2[0] + v1[2] * v2[1] + v1[1] * v2[2] + v1[3] * v2[3] +
            v1[4] * v2[4] + v1[6] * v2[5] + v1[5] * v2[6]);
  dtrial[3] =
      2. * (v1[0] * v2[0] + v1[2] * v2[1] + v1[3] * v2[2] + v1[1] * v2[3] +
            v1[6] * v2[4] + v1[4] * v2[5] + v1[5] * v2[6]);
  dtrial[4] =
      2. * (v1[0] * v2[0] + v1[3] * v2[1] + v1[1] * v2[2] + v1[2] * v2[3] +
            v1[5] * v2[4] + v1[6] * v2[5] + v1[4] * v2[6]);
  dtrial[5] =
      2. * (v1[0] * v2[0] + v1[3] * v2[1] + v1[2] * v2[2] + v1[1] * v2[3] +
            v1[6] * v2[4] + v1[5] * v2[5] + v1[4] * v2[6]);
  dtrial[6] =
      2. * (v1[1] * v2[0] + v1[0] * v2[1] + v1[2] * v2[2] + v1[3] * v2[3] +
            v1[5] * v2[4] + v1[4] * v2[5] + v1[6] * v2[6]);
  dtrial[7] =
      2. * (v1[1] * v2[0] + v1[0] * v2[1] + v1[3] * v2[2] + v1[2] * v2[3] +
            v1[4] * v2[4] + v1[5] * v2[5] + v1[6] * v2[6]);
  dtrial[8] =
      2. * (v1[1] * v2[0] + v1[2] * v2[1] + v1[0] * v2[2] + v1[3] * v2[3] +
            v1[5] * v2[4] + v1[6] * v2[5] + v1[4] * v2[6]);
  dtrial[9] =
      2. * (v1[1] * v2[0] + v1[2] * v2[1] + v1[3] * v2[2] + v1[0] * v2[3] +
            v1[6] * v2[4] + v1[5] * v2[5] + v1[4] * v2[6]);
  dtrial[10] =
      2. * (v1[1] * v2[0] + v1[3] * v2[1] + v1[0] * v2[2] + v1[2] * v2[3] +
            v1[4] * v2[4] + v1[6] * v2[5] + v1[5] * v2[6]);
  dtrial[11] =
      2. * (v1[1] * v2[0] + v1[3] * v2[1] + v1[2] * v2[2] + v1[0] * v2[3] +
            v1[6] * v2[4] + v1[4] * v2[5] + v1[5] * v2[6]);
  dtrial[12] =
      2. * (v1[2] * v2[0] + v1[0] * v2[1] + v1[1] * v2[2] + v1[3] * v2[3] +
            v1[6] * v2[4] + v1[4] * v2[5] + v1[5] * v2[6]);
  dtrial[13] =
      2. * (v1[2] * v2[0] + v1[0] * v2[1] + v1[3] * v2[2] + v1[1] * v2[3] +
            v1[4] * v2[4] + v1[6] * v2[5] + v1[5] * v2[6]);
  dtrial[14] =
      2. * (v1[2] * v2[0] + v1[1] * v2[1] + v1[0] * v2[2] + v1[3] * v2[3] +
            v1[6] * v2[4] + v1[5] * v2[5] + v1[4] * v2[6]);
  dtrial[15] =
      2. * (v1[2] * v2[0] + v1[1] * v2[1] + v1[3] * v2[2] + v1[0] * v2[3] +
            v1[5] * v2[4] + v1[6] * v2[5] + v1[4] * v2[6]);
  dtrial[16] =
      2. * (v1[2] * v2[0] + v1[3] * v2[1] + v1[0] * v2[2] + v1[1] * v2[3] +
            v1[4] * v2[4] + v1[5] * v2[5] + v1[6] * v2[6]);
  dtrial[17] =
      2. * (v1[2] * v2[0] + v1[3] * v2[1] + v1[1] * v2[2] + v1[0] * v2[3] +
            v1[5] * v2[4] + v1[4] * v2[5] + v1[6] * v2[6]);
  dtrial[18] =
      2. * (v1[3] * v2[0] + v1[0] * v2[1] + v1[1] * v2[2] + v1[2] * v2[3] +
            v1[6] * v2[4] + v1[5] * v2[5] + v1[4] * v2[6]);
  dtrial[19] =
      2. * (v1[3] * v2[0] + v1[0] * v2[1] + v1[2] * v2[2] + v1[1] * v2[3] +
            v1[5] * v2[4] + v1[6] * v2[5] + v1[4] * v2[6]);
  dtrial[20] =
      2. * (v1[3] * v2[0] + v1[1] * v2[1] + v1[0] * v2[2] + v1[2] * v2[3] +
            v1[6] * v2[4] + v1[4] * v2[5] + v1[5] * v2[6]);
  dtrial[21] =
      2. * (v1[3] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2] + v1[0] * v2[3] +
            v1[4] * v2[4] + v1[6] * v2[5] + v1[5] * v2[6]);
  dtrial[22] =
      2. * (v1[3] * v2[0] + v1[2] * v2[1] + v1[0] * v2[2] + v1[1] * v2[3] +
            v1[5] * v2[4] + v1[4] * v2[5] + v1[6] * v2[6]);
  dtrial[23] =
      2. * (v1[3] * v2[0] + v1[2] * v2[1] + v1[1] * v2[2] + v1[0] * v2[3] +
            v1[4] * v2[4] + v1[5] * v2[5] + v1[6] * v2[6]);
  dwnby = dtrial[0];
  for (i = 1; i < 24; i++)
    if (dtrial[i] > dwnby)
      dwnby = dtrial[i];
  return (fabs(distsq - dwnby));
}


x86 assembly (clang, -O0):
<d71234distsq>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1cd7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1c17(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1b57(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1a97(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x19d7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1917(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1857(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1797(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x16d7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1617(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1557(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1497(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x13d7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x131a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x125d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x11a0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10e3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1026(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xf69(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xeac(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xdef(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd32(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xc75(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xbb8(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x20(%rbp)
movl   $0x1,-0xe4(%rbp)
cmpl   $0x18,-0xe4(%rbp)
jge    24be <d71234distsq+0x13be>
movslq -0xe4(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x20(%rbp),%xmm0
jbe    24a5 <d71234distsq+0x13a5>
movslq -0xe4(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x20(%rbp)
jmp    24aa <d71234distsq+0x13aa>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    2468 <d71234distsq+0x1368>
movsd  -0x18(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movaps 0xb41(%rip),%xmm1
pand   %xmm1,%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<d71234distsq>:
sub    $0x178,%rsp
movsd  (%rdi),%xmm8
movsd  %xmm8,-0x18(%rsp)
movsd  0x8(%rdi),%xmm3
movupd 0x10(%rdi),%xmm15
movupd 0x20(%rdi),%xmm13
movsd  (%rsi),%xmm1
movsd  0x8(%rsi),%xmm0
movsd  0x10(%rsi),%xmm7
movapd %xmm7,0xb0(%rsp)
movsd  0x18(%rsi),%xmm5
movapd %xmm5,0xf0(%rsp)
movsd  0x20(%rsi),%xmm11
movsd  0x28(%rsi),%xmm10
movapd %xmm10,0x20(%rsp)
movapd %xmm3,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,-0x28(%rsp)
movapd %xmm0,%xmm9
mulsd  %xmm1,%xmm8
movapd %xmm1,%xmm4
movapd %xmm8,%xmm6
addsd  %xmm2,%xmm6
movapd %xmm7,%xmm1
unpcklpd %xmm7,%xmm1
unpcklpd %xmm6,%xmm6
movapd %xmm15,%xmm2
shufpd $0x1,%xmm15,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm6,%xmm2
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
mulpd  %xmm15,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm13,%xmm1
shufpd $0x1,%xmm13,%xmm1
movapd %xmm11,%xmm2
movapd %xmm11,%xmm6
unpcklpd %xmm11,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movapd %xmm10,%xmm0
unpcklpd %xmm10,%xmm0
mulpd  %xmm13,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm0,0x160(%rsp)
movsd  %xmm8,0x58(%rsp)
movapd %xmm15,%xmm14
unpckhpd %xmm15,%xmm14
movapd %xmm14,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm9,%xmm10
addsd  %xmm0,%xmm8
movapd %xmm3,%xmm12
movsd  %xmm4,-0x20(%rsp)
mulsd  %xmm4,%xmm12
movsd  %xmm12,-0x30(%rsp)
movsd  %xmm12,-0x68(%rsp)
addsd  %xmm0,%xmm12
movapd %xmm15,%xmm11
mulsd  %xmm4,%xmm11
movapd %xmm11,-0x60(%rsp)
movapd %xmm11,(%rsp)
addsd  %xmm0,%xmm11
movapd %xmm13,%xmm7
movapd %xmm13,0xd0(%rsp)
movapd %xmm13,%xmm9
unpckhpd %xmm13,%xmm9
movsd  0x30(%rdi),%xmm13
movsd  %xmm13,-0x38(%rsp)
movsd  0x30(%rsi),%xmm0
movapd %xmm0,0x10(%rsp)
mulsd  %xmm0,%xmm13
movapd %xmm15,%xmm0
movsd  %xmm10,0x50(%rsp)
mulsd  %xmm10,%xmm0
movapd %xmm0,0x130(%rsp)
movapd %xmm3,%xmm2
movsd  %xmm3,0x48(%rsp)
movapd %xmm3,%xmm5
movapd 0xb0(%rsp),%xmm4
mulsd  %xmm4,%xmm5
movapd %xmm14,%xmm1
movapd 0xf0(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm1,0x80(%rsp)
movapd %xmm7,%xmm1
movapd %xmm6,0xe0(%rsp)
mulsd  %xmm6,%xmm1
movapd %xmm1,-0x10(%rsp)
movapd %xmm14,%xmm1
movapd %xmm14,0x140(%rsp)
mulsd  %xmm4,%xmm1
movapd %xmm1,0x90(%rsp)
mulsd  %xmm3,%xmm2
movsd  %xmm2,-0x48(%rsp)
movapd 0x20(%rsp),%xmm1
mulsd  %xmm1,%xmm7
movapd %xmm7,0x70(%rsp)
movapd %xmm5,%xmm0
addsd  %xmm8,%xmm0
movsd  %xmm0,0x40(%rsp)
movapd %xmm15,0x150(%rsp)
movapd %xmm15,%xmm7
mulsd  %xmm3,%xmm7
movapd %xmm7,0xa0(%rsp)
movapd %xmm3,%xmm7
movapd %xmm9,0xc0(%rsp)
movapd %xmm9,%xmm2
mulsd  %xmm6,%xmm2
movapd %xmm2,0x60(%rsp)
movapd %xmm15,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm0,%xmm8
movsd  %xmm8,-0x78(%rsp)
mulsd  %xmm1,%xmm9
movapd %xmm9,%xmm6
movsd  -0x18(%rsp),%xmm1
movapd %xmm1,%xmm15
mulsd  %xmm10,%xmm15
movsd  -0x30(%rsp),%xmm2
addsd  %xmm15,%xmm2
movapd %xmm1,%xmm3
movapd %xmm1,%xmm9
mulsd  %xmm4,%xmm3
movapd %xmm3,%xmm1
addsd  %xmm12,%xmm1
movsd  %xmm1,-0x70(%rsp)
addsd  %xmm0,%xmm12
movsd  %xmm12,0x38(%rsp)
movapd -0x60(%rsp),%xmm1
addsd  %xmm15,%xmm1
movapd %xmm1,-0x60(%rsp)
movsd  -0x28(%rsp),%xmm1
movapd (%rsp),%xmm4
addsd  %xmm1,%xmm4
movapd %xmm4,(%rsp)
movapd %xmm14,%xmm8
mulsd  -0x20(%rsp),%xmm8
addsd  %xmm8,%xmm15
movapd %xmm5,%xmm10
addsd  %xmm15,%xmm5
movsd  %xmm5,-0x80(%rsp)
addsd  %xmm0,%xmm15
addsd  %xmm8,%xmm1
movapd %xmm3,%xmm5
addsd  %xmm1,%xmm5
movsd  %xmm5,-0x40(%rsp)
addsd  %xmm0,%xmm1
movsd  %xmm1,-0x28(%rsp)
movapd %xmm0,%xmm12
movapd %xmm2,%xmm0
addsd  %xmm2,%xmm12
addsd  0x80(%rsp),%xmm12
movapd 0x60(%rsp),%xmm5
addsd  %xmm5,%xmm12
movapd 0x70(%rsp),%xmm2
addsd  %xmm2,%xmm12
addsd  %xmm13,%xmm12
addsd  0x90(%rsp),%xmm0
addsd  0xa0(%rsp),%xmm0
movapd -0x10(%rsp),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm6,%xmm4
movapd %xmm6,0x100(%rsp)
addsd  %xmm6,%xmm0
addsd  %xmm13,%xmm0
movsd  %xmm0,-0x30(%rsp)
movapd %xmm9,%xmm6
mulsd  %xmm7,%xmm6
movsd  %xmm6,-0x50(%rsp)
movapd %xmm3,%xmm0
movapd %xmm3,%xmm14
addsd  %xmm11,%xmm14
movsd  -0x48(%rsp),%xmm3
addsd  %xmm3,%xmm14
addsd  %xmm1,%xmm14
movapd %xmm1,%xmm9
addsd  %xmm4,%xmm14
addsd  %xmm13,%xmm14
movapd %xmm10,%xmm7
addsd  %xmm10,%xmm11
addsd  %xmm6,%xmm11
addsd  %xmm5,%xmm11
addsd  %xmm2,%xmm11
addsd  %xmm13,%xmm11
movapd %xmm11,0x120(%rsp)
movapd %xmm8,%xmm4
movapd 0x130(%rsp),%xmm1
addsd  %xmm1,%xmm4
movapd %xmm0,%xmm6
movapd %xmm0,%xmm10
addsd  %xmm4,%xmm0
addsd  %xmm3,%xmm0
addsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm13,%xmm0
movsd  %xmm0,0x30(%rsp)
movapd %xmm7,%xmm3
addsd  %xmm7,%xmm4
movsd  -0x50(%rsp),%xmm8
addsd  %xmm8,%xmm4
addsd  %xmm9,%xmm4
movapd 0x100(%rsp),%xmm11
addsd  %xmm11,%xmm4
addsd  %xmm13,%xmm4
movapd %xmm4,0x110(%rsp)
movapd %xmm13,%xmm7
unpcklpd %xmm13,%xmm7
addpd  0x160(%rsp),%xmm7
movsd  0x58(%rsp),%xmm5
addsd  %xmm1,%xmm5
movsd  -0x68(%rsp),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm3,%xmm13
movapd %xmm3,%xmm4
addsd  %xmm5,%xmm4
movapd 0x80(%rsp),%xmm3
addsd  %xmm3,%xmm4
addsd  %xmm0,%xmm6
addsd  %xmm3,%xmm6
movapd -0x60(%rsp),%xmm1
addsd  %xmm1,%xmm13
addsd  %xmm3,%xmm13
movapd (%rsp),%xmm9
addsd  %xmm9,%xmm10
addsd  %xmm3,%xmm10
movapd 0x90(%rsp),%xmm3
addsd  %xmm3,%xmm5
addsd  %xmm3,%xmm0
addsd  %xmm3,%xmm1
addsd  %xmm3,%xmm9
movsd  -0x38(%rsp),%xmm2
mulsd  0xe0(%rsp),%xmm2
movsd  -0x78(%rsp),%xmm3
addsd  -0x48(%rsp),%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm11,%xmm3
movsd  %xmm3,-0x78(%rsp)
addsd  %xmm8,%xmm0
movapd %xmm8,%xmm3
addsd  %xmm2,%xmm0
movapd %xmm11,%xmm8
addsd  %xmm11,%xmm0
movsd  %xmm0,-0x68(%rsp)
addsd  %xmm2,%xmm10
addsd  %xmm11,%xmm10
movsd  -0x80(%rsp),%xmm0
movapd 0xa0(%rsp),%xmm11
addsd  %xmm11,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm8,%xmm0
movsd  %xmm0,-0x80(%rsp)
movsd  -0x48(%rsp),%xmm0
addsd  %xmm0,%xmm5
addsd  %xmm0,%xmm1
movapd %xmm1,-0x60(%rsp)
addsd  %xmm0,%xmm15
movsd  0x40(%rsp),%xmm0
addsd  %xmm11,%xmm0
movapd %xmm11,%xmm8
movapd 0x60(%rsp),%xmm1
addsd  %xmm1,%xmm0
addsd  %xmm1,%xmm6
addsd  %xmm3,%xmm9
addsd  %xmm1,%xmm9
movapd %xmm9,%xmm11
addsd  %xmm1,%xmm15
movsd  -0x38(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm9
movapd 0xd0(%rsp),%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  %xmm0,%xmm9
movsd  -0x78(%rsp),%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,-0x78(%rsp)
addsd  %xmm1,%xmm6
addsd  %xmm0,%xmm6
movsd  -0x68(%rsp),%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,-0x68(%rsp)
addsd  %xmm0,%xmm10
addsd  %xmm1,%xmm11
addsd  %xmm0,%xmm11
movsd  -0x80(%rsp),%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,-0x80(%rsp)
addsd  %xmm1,%xmm15
addsd  %xmm0,%xmm15
movsd  -0x70(%rsp),%xmm0
addsd  %xmm8,%xmm0
movsd  %xmm0,-0x70(%rsp)
movsd  -0x40(%rsp),%xmm3
addsd  %xmm8,%xmm3
addsd  %xmm2,%xmm5
movsd  0x38(%rsp),%xmm8
addsd  -0x50(%rsp),%xmm8
addsd  %xmm2,%xmm8
addsd  %xmm2,%xmm13
addsd  %xmm2,%xmm3
movapd 0x70(%rsp),%xmm2
addsd  %xmm2,%xmm5
addsd  %xmm2,%xmm8
addsd  %xmm2,%xmm13
addsd  %xmm2,%xmm3
movsd  %xmm3,-0x40(%rsp)
movsd  -0x28(%rsp),%xmm2
addsd  -0x50(%rsp),%xmm2
movapd -0x10(%rsp),%xmm0
addsd  %xmm0,%xmm4
movsd  -0x70(%rsp),%xmm3
addsd  %xmm0,%xmm3
movapd -0x60(%rsp),%xmm0
addsd  -0x10(%rsp),%xmm0
addsd  -0x10(%rsp),%xmm2
addsd  %xmm1,%xmm4
addsd  %xmm1,%xmm3
addsd  %xmm1,%xmm0
movapd %xmm0,-0x60(%rsp)
addsd  %xmm1,%xmm2
movapd 0xc0(%rsp),%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  %xmm0,%xmm4
addsd  %xmm0,%xmm5
addsd  %xmm0,%xmm3
movsd  %xmm3,-0x70(%rsp)
addsd  %xmm0,%xmm8
addsd  %xmm0,%xmm13
movapd -0x60(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,-0x60(%rsp)
movsd  -0x40(%rsp),%xmm3
addsd  %xmm0,%xmm3
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm1
addpd  %xmm7,%xmm7
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
maxsd  %xmm0,%xmm7
addsd  %xmm4,%xmm4
maxsd  %xmm7,%xmm4
addsd  %xmm5,%xmm5
maxsd  %xmm4,%xmm5
addsd  %xmm9,%xmm9
maxsd  %xmm5,%xmm9
movsd  -0x78(%rsp),%xmm0
addsd  %xmm0,%xmm0
maxsd  %xmm9,%xmm0
addsd  %xmm12,%xmm12
maxsd  %xmm0,%xmm12
movsd  -0x30(%rsp),%xmm0
addsd  %xmm0,%xmm0
maxsd  %xmm12,%xmm0
addsd  %xmm6,%xmm6
maxsd  %xmm0,%xmm6
movsd  -0x68(%rsp),%xmm0
addsd  %xmm0,%xmm0
maxsd  %xmm6,%xmm0
movapd %xmm0,%xmm2
movsd  -0x70(%rsp),%xmm0
addsd  %xmm0,%xmm0
maxsd  %xmm2,%xmm0
addsd  %xmm8,%xmm8
maxsd  %xmm0,%xmm8
addsd  %xmm13,%xmm13
maxsd  %xmm8,%xmm13
movapd -0x60(%rsp),%xmm0
addsd  %xmm0,%xmm0
maxsd  %xmm13,%xmm0
addsd  %xmm10,%xmm10
maxsd  %xmm0,%xmm10
addsd  %xmm11,%xmm11
maxsd  %xmm10,%xmm11
addsd  %xmm14,%xmm14
maxsd  %xmm11,%xmm14
movapd 0x120(%rsp),%xmm0
addsd  %xmm0,%xmm0
maxsd  %xmm14,%xmm0
movsd  -0x80(%rsp),%xmm2
addsd  %xmm2,%xmm2
maxsd  %xmm0,%xmm2
addsd  %xmm15,%xmm15
maxsd  %xmm2,%xmm15
movapd %xmm3,%xmm0
addsd  %xmm3,%xmm0
maxsd  %xmm15,%xmm0
addsd  %xmm1,%xmm1
maxsd  %xmm0,%xmm1
movsd  0x30(%rsp),%xmm0
addsd  %xmm0,%xmm0
maxsd  %xmm1,%xmm0
movapd 0x110(%rsp),%xmm2
addsd  %xmm2,%xmm2
maxsd  %xmm0,%xmm2
movsd  0x48(%rsp),%xmm1
mulsd  %xmm1,%xmm1
movsd  -0x18(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd 0x150(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movapd 0x140(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movapd 0xd0(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd 0xc0(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd  -0x20(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd  0x50(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd 0xb0(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movapd 0xf0(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movapd 0xe0(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movapd 0x20(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd 0x10(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
andpd  0x5d2(%rip),%xmm1
movapd %xmm1,%xmm0
add    $0x178,%rsp
ret

LLVM IR (-O0):
define double @d71234distsq(double* %0, double* %1) {
%3 = alloca double*
%4 = alloca double*
%5 = alloca double
%6 = alloca double
%7 = alloca [24 x double]
%8 = alloca i32
store double* %0, double** %3
store double* %1, double** %4
%9 = load double*, double** %3
%10 = getelementptr inbounds double, double* %9, i64 0
%11 = load double, double* %10
%12 = load double*, double** %3
%13 = getelementptr inbounds double, double* %12, i64 0
%14 = load double, double* %13
%15 = load double*, double** %3
%16 = getelementptr inbounds double, double* %15, i64 1
%17 = load double, double* %16
%18 = load double*, double** %3
%19 = getelementptr inbounds double, double* %18, i64 1
%20 = load double, double* %19
%21 = fmul double %17, %20
%22 = call double @llvm.fmuladd.f64(double %11, double %14, double %21)
%23 = load double*, double** %3
%24 = getelementptr inbounds double, double* %23, i64 2
%25 = load double, double* %24
%26 = load double*, double** %3
%27 = getelementptr inbounds double, double* %26, i64 2
%28 = load double, double* %27
%29 = call double @llvm.fmuladd.f64(double %25, double %28, double %22)
%30 = load double*, double** %3
%31 = getelementptr inbounds double, double* %30, i64 3
%32 = load double, double* %31
%33 = load double*, double** %3
%34 = getelementptr inbounds double, double* %33, i64 3
%35 = load double, double* %34
%36 = call double @llvm.fmuladd.f64(double %32, double %35, double %29)
%37 = load double*, double** %3
%38 = getelementptr inbounds double, double* %37, i64 4
%39 = load double, double* %38
%40 = load double*, double** %3
%41 = getelementptr inbounds double, double* %40, i64 4
%42 = load double, double* %41
%43 = call double @llvm.fmuladd.f64(double %39, double %42, double %36)
%44 = load double*, double** %3
%45 = getelementptr inbounds double, double* %44, i64 5
%46 = load double, double* %45
%47 = load double*, double** %3
%48 = getelementptr inbounds double, double* %47, i64 5
%49 = load double, double* %48
%50 = call double @llvm.fmuladd.f64(double %46, double %49, double %43)
%51 = load double*, double** %3
%52 = getelementptr inbounds double, double* %51, i64 6
%53 = load double, double* %52
%54 = load double*, double** %3
%55 = getelementptr inbounds double, double* %54, i64 6
%56 = load double, double* %55
%57 = call double @llvm.fmuladd.f64(double %53, double %56, double %50)
%58 = load double*, double** %4
%59 = getelementptr inbounds double, double* %58, i64 0
%60 = load double, double* %59
%61 = load double*, double** %4
%62 = getelementptr inbounds double, double* %61, i64 0
%63 = load double, double* %62
%64 = call double @llvm.fmuladd.f64(double %60, double %63, double %57)
%65 = load double*, double** %4
%66 = getelementptr inbounds double, double* %65, i64 1
%67 = load double, double* %66
%68 = load double*, double** %4
%69 = getelementptr inbounds double, double* %68, i64 1
%70 = load double, double* %69
%71 = call double @llvm.fmuladd.f64(double %67, double %70, double %64)
%72 = load double*, double** %4
%73 = getelementptr inbounds double, double* %72, i64 2
%74 = load double, double* %73
%75 = load double*, double** %4
%76 = getelementptr inbounds double, double* %75, i64 2
%77 = load double, double* %76
%78 = call double @llvm.fmuladd.f64(double %74, double %77, double %71)
%79 = load double*, double** %4
%80 = getelementptr inbounds double, double* %79, i64 3
%81 = load double, double* %80
%82 = load double*, double** %4
%83 = getelementptr inbounds double, double* %82, i64 3
%84 = load double, double* %83
%85 = call double @llvm.fmuladd.f64(double %81, double %84, double %78)
%86 = load double*, double** %4
%87 = getelementptr inbounds double, double* %86, i64 4
%88 = load double, double* %87
%89 = load double*, double** %4
%90 = getelementptr inbounds double, double* %89, i64 4
%91 = load double, double* %90
%92 = call double @llvm.fmuladd.f64(double %88, double %91, double %85)
%93 = load double*, double** %4
%94 = getelementptr inbounds double, double* %93, i64 5
%95 = load double, double* %94
%96 = load double*, double** %4
%97 = getelementptr inbounds double, double* %96, i64 5
%98 = load double, double* %97
%99 = call double @llvm.fmuladd.f64(double %95, double %98, double %92)
%100 = load double*, double** %4
%101 = getelementptr inbounds double, double* %100, i64 6
%102 = load double, double* %101
%103 = load double*, double** %4
%104 = getelementptr inbounds double, double* %103, i64 6
%105 = load double, double* %104
%106 = call double @llvm.fmuladd.f64(double %102, double %105, double %99)
store double %106, double* %5
%107 = load double*, double** %3
%108 = getelementptr inbounds double, double* %107, i64 0
%109 = load double, double* %108
%110 = load double*, double** %4
%111 = getelementptr inbounds double, double* %110, i64 0
%112 = load double, double* %111
%113 = load double*, double** %3
%114 = getelementptr inbounds double, double* %113, i64 1
%115 = load double, double* %114
%116 = load double*, double** %4
%117 = getelementptr inbounds double, double* %116, i64 1
%118 = load double, double* %117
%119 = fmul double %115, %118
%120 = call double @llvm.fmuladd.f64(double %109, double %112, double %119)
%121 = load double*, double** %3
%122 = getelementptr inbounds double, double* %121, i64 2
%123 = load double, double* %122
%124 = load double*, double** %4
%125 = getelementptr inbounds double, double* %124, i64 2
%126 = load double, double* %125
%127 = call double @llvm.fmuladd.f64(double %123, double %126, double %120)
%128 = load double*, double** %3
%129 = getelementptr inbounds double, double* %128, i64 3
%130 = load double, double* %129
%131 = load double*, double** %4
%132 = getelementptr inbounds double, double* %131, i64 3
%133 = load double, double* %132
%134 = call double @llvm.fmuladd.f64(double %130, double %133, double %127)
%135 = load double*, double** %3
%136 = getelementptr inbounds double, double* %135, i64 4
%137 = load double, double* %136
%138 = load double*, double** %4
%139 = getelementptr inbounds double, double* %138, i64 4
%140 = load double, double* %139
%141 = call double @llvm.fmuladd.f64(double %137, double %140, double %134)
%142 = load double*, double** %3
%143 = getelementptr inbounds double, double* %142, i64 5
%144 = load double, double* %143
%145 = load double*, double** %4
%146 = getelementptr inbounds double, double* %145, i64 5
%147 = load double, double* %146
%148 = call double @llvm.fmuladd.f64(double %144, double %147, double %141)
%149 = load double*, double** %3
%150 = getelementptr inbounds double, double* %149, i64 6
%151 = load double, double* %150
%152 = load double*, double** %4
%153 = getelementptr inbounds double, double* %152, i64 6
%154 = load double, double* %153
%155 = call double @llvm.fmuladd.f64(double %151, double %154, double %148)
%156 = fmul double 2.000000e+00, %155
%157 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 0
store double %156, double* %157
%158 = load double*, double** %3
%159 = getelementptr inbounds double, double* %158, i64 0
%160 = load double, double* %159
%161 = load double*, double** %4
%162 = getelementptr inbounds double, double* %161, i64 0
%163 = load double, double* %162
%164 = load double*, double** %3
%165 = getelementptr inbounds double, double* %164, i64 1
%166 = load double, double* %165
%167 = load double*, double** %4
%168 = getelementptr inbounds double, double* %167, i64 1
%169 = load double, double* %168
%170 = fmul double %166, %169
%171 = call double @llvm.fmuladd.f64(double %160, double %163, double %170)
%172 = load double*, double** %3
%173 = getelementptr inbounds double, double* %172, i64 3
%174 = load double, double* %173
%175 = load double*, double** %4
%176 = getelementptr inbounds double, double* %175, i64 2
%177 = load double, double* %176
%178 = call double @llvm.fmuladd.f64(double %174, double %177, double %171)
%179 = load double*, double** %3
%180 = getelementptr inbounds double, double* %179, i64 2
%181 = load double, double* %180
%182 = load double*, double** %4
%183 = getelementptr inbounds double, double* %182, i64 3
%184 = load double, double* %183
%185 = call double @llvm.fmuladd.f64(double %181, double %184, double %178)
%186 = load double*, double** %3
%187 = getelementptr inbounds double, double* %186, i64 5
%188 = load double, double* %187
%189 = load double*, double** %4
%190 = getelementptr inbounds double, double* %189, i64 4
%191 = load double, double* %190
%192 = call double @llvm.fmuladd.f64(double %188, double %191, double %185)
%193 = load double*, double** %3
%194 = getelementptr inbounds double, double* %193, i64 4
%195 = load double, double* %194
%196 = load double*, double** %4
%197 = getelementptr inbounds double, double* %196, i64 5
%198 = load double, double* %197
%199 = call double @llvm.fmuladd.f64(double %195, double %198, double %192)
%200 = load double*, double** %3
%201 = getelementptr inbounds double, double* %200, i64 6
%202 = load double, double* %201
%203 = load double*, double** %4
%204 = getelementptr inbounds double, double* %203, i64 6
%205 = load double, double* %204
%206 = call double @llvm.fmuladd.f64(double %202, double %205, double %199)
%207 = fmul double 2.000000e+00, %206
%208 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 1
store double %207, double* %208
%209 = load double*, double** %3
%210 = getelementptr inbounds double, double* %209, i64 0
%211 = load double, double* %210
%212 = load double*, double** %4
%213 = getelementptr inbounds double, double* %212, i64 0
%214 = load double, double* %213
%215 = load double*, double** %3
%216 = getelementptr inbounds double, double* %215, i64 2
%217 = load double, double* %216
%218 = load double*, double** %4
%219 = getelementptr inbounds double, double* %218, i64 1
%220 = load double, double* %219
%221 = fmul double %217, %220
%222 = call double @llvm.fmuladd.f64(double %211, double %214, double %221)
%223 = load double*, double** %3
%224 = getelementptr inbounds double, double* %223, i64 1
%225 = load double, double* %224
%226 = load double*, double** %4
%227 = getelementptr inbounds double, double* %226, i64 2
%228 = load double, double* %227
%229 = call double @llvm.fmuladd.f64(double %225, double %228, double %222)
%230 = load double*, double** %3
%231 = getelementptr inbounds double, double* %230, i64 3
%232 = load double, double* %231
%233 = load double*, double** %4
%234 = getelementptr inbounds double, double* %233, i64 3
%235 = load double, double* %234
%236 = call double @llvm.fmuladd.f64(double %232, double %235, double %229)
%237 = load double*, double** %3
%238 = getelementptr inbounds double, double* %237, i64 4
%239 = load double, double* %238
%240 = load double*, double** %4
%241 = getelementptr inbounds double, double* %240, i64 4
%242 = load double, double* %241
%243 = call double @llvm.fmuladd.f64(double %239, double %242, double %236)
%244 = load double*, double** %3
%245 = getelementptr inbounds double, double* %244, i64 6
%246 = load double, double* %245
%247 = load double*, double** %4
%248 = getelementptr inbounds double, double* %247, i64 5
%249 = load double, double* %248
%250 = call double @llvm.fmuladd.f64(double %246, double %249, double %243)
%251 = load double*, double** %3
%252 = getelementptr inbounds double, double* %251, i64 5
%253 = load double, double* %252
%254 = load double*, double** %4
%255 = getelementptr inbounds double, double* %254, i64 6
%256 = load double, double* %255
%257 = call double @llvm.fmuladd.f64(double %253, double %256, double %250)
%258 = fmul double 2.000000e+00, %257
%259 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 2
store double %258, double* %259
%260 = load double*, double** %3
%261 = getelementptr inbounds double, double* %260, i64 0
%262 = load double, double* %261
%263 = load double*, double** %4
%264 = getelementptr inbounds double, double* %263, i64 0
%265 = load double, double* %264
%266 = load double*, double** %3
%267 = getelementptr inbounds double, double* %266, i64 2
%268 = load double, double* %267
%269 = load double*, double** %4
%270 = getelementptr inbounds double, double* %269, i64 1
%271 = load double, double* %270
%272 = fmul double %268, %271
%273 = call double @llvm.fmuladd.f64(double %262, double %265, double %272)
%274 = load double*, double** %3
%275 = getelementptr inbounds double, double* %274, i64 3
%276 = load double, double* %275
%277 = load double*, double** %4
%278 = getelementptr inbounds double, double* %277, i64 2
%279 = load double, double* %278
%280 = call double @llvm.fmuladd.f64(double %276, double %279, double %273)
%281 = load double*, double** %3
%282 = getelementptr inbounds double, double* %281, i64 1
%283 = load double, double* %282
%284 = load double*, double** %4
%285 = getelementptr inbounds double, double* %284, i64 3
%286 = load double, double* %285
%287 = call double @llvm.fmuladd.f64(double %283, double %286, double %280)
%288 = load double*, double** %3
%289 = getelementptr inbounds double, double* %288, i64 6
%290 = load double, double* %289
%291 = load double*, double** %4
%292 = getelementptr inbounds double, double* %291, i64 4
%293 = load double, double* %292
%294 = call double @llvm.fmuladd.f64(double %290, double %293, double %287)
%295 = load double*, double** %3
%296 = getelementptr inbounds double, double* %295, i64 4
%297 = load double, double* %296
%298 = load double*, double** %4
%299 = getelementptr inbounds double, double* %298, i64 5
%300 = load double, double* %299
%301 = call double @llvm.fmuladd.f64(double %297, double %300, double %294)
%302 = load double*, double** %3
%303 = getelementptr inbounds double, double* %302, i64 5
%304 = load double, double* %303
%305 = load double*, double** %4
%306 = getelementptr inbounds double, double* %305, i64 6
%307 = load double, double* %306
%308 = call double @llvm.fmuladd.f64(double %304, double %307, double %301)
%309 = fmul double 2.000000e+00, %308
%310 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 3
store double %309, double* %310
%311 = load double*, double** %3
%312 = getelementptr inbounds double, double* %311, i64 0
%313 = load double, double* %312
%314 = load double*, double** %4
%315 = getelementptr inbounds double, double* %314, i64 0
%316 = load double, double* %315
%317 = load double*, double** %3
%318 = getelementptr inbounds double, double* %317, i64 3
%319 = load double, double* %318
%320 = load double*, double** %4
%321 = getelementptr inbounds double, double* %320, i64 1
%322 = load double, double* %321
%323 = fmul double %319, %322
%324 = call double @llvm.fmuladd.f64(double %313, double %316, double %323)
%325 = load double*, double** %3
%326 = getelementptr inbounds double, double* %325, i64 1
%327 = load double, double* %326
%328 = load double*, double** %4
%329 = getelementptr inbounds double, double* %328, i64 2
%330 = load double, double* %329
%331 = call double @llvm.fmuladd.f64(double %327, double %330, double %324)
%332 = load double*, double** %3
%333 = getelementptr inbounds double, double* %332, i64 2
%334 = load double, double* %333
%335 = load double*, double** %4
%336 = getelementptr inbounds double, double* %335, i64 3
%337 = load double, double* %336
%338 = call double @llvm.fmuladd.f64(double %334, double %337, double %331)
%339 = load double*, double** %3
%340 = getelementptr inbounds double, double* %339, i64 5
%341 = load double, double* %340
%342 = load double*, double** %4
%343 = getelementptr inbounds double, double* %342, i64 4
%344 = load double, double* %343
%345 = call double @llvm.fmuladd.f64(double %341, double %344, double %338)
%346 = load double*, double** %3
%347 = getelementptr inbounds double, double* %346, i64 6
%348 = load double, double* %347
%349 = load double*, double** %4
%350 = getelementptr inbounds double, double* %349, i64 5
%351 = load double, double* %350
%352 = call double @llvm.fmuladd.f64(double %348, double %351, double %345)
%353 = load double*, double** %3
%354 = getelementptr inbounds double, double* %353, i64 4
%355 = load double, double* %354
%356 = load double*, double** %4
%357 = getelementptr inbounds double, double* %356, i64 6
%358 = load double, double* %357
%359 = call double @llvm.fmuladd.f64(double %355, double %358, double %352)
%360 = fmul double 2.000000e+00, %359
%361 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 4
store double %360, double* %361
%362 = load double*, double** %3
%363 = getelementptr inbounds double, double* %362, i64 0
%364 = load double, double* %363
%365 = load double*, double** %4
%366 = getelementptr inbounds double, double* %365, i64 0
%367 = load double, double* %366
%368 = load double*, double** %3
%369 = getelementptr inbounds double, double* %368, i64 3
%370 = load double, double* %369
%371 = load double*, double** %4
%372 = getelementptr inbounds double, double* %371, i64 1
%373 = load double, double* %372
%374 = fmul double %370, %373
%375 = call double @llvm.fmuladd.f64(double %364, double %367, double %374)
%376 = load double*, double** %3
%377 = getelementptr inbounds double, double* %376, i64 2
%378 = load double, double* %377
%379 = load double*, double** %4
%380 = getelementptr inbounds double, double* %379, i64 2
%381 = load double, double* %380
%382 = call double @llvm.fmuladd.f64(double %378, double %381, double %375)
%383 = load double*, double** %3
%384 = getelementptr inbounds double, double* %383, i64 1
%385 = load double, double* %384
%386 = load double*, double** %4
%387 = getelementptr inbounds double, double* %386, i64 3
%388 = load double, double* %387
%389 = call double @llvm.fmuladd.f64(double %385, double %388, double %382)
%390 = load double*, double** %3
%391 = getelementptr inbounds double, double* %390, i64 6
%392 = load double, double* %391
%393 = load double*, double** %4
%394 = getelementptr inbounds double, double* %393, i64 4
%395 = load double, double* %394
%396 = call double @llvm.fmuladd.f64(double %392, double %395, double %389)
%397 = load double*, double** %3
%398 = getelementptr inbounds double, double* %397, i64 5
%399 = load double, double* %398
%400 = load double*, double** %4
%401 = getelementptr inbounds double, double* %400, i64 5
%402 = load double, double* %401
%403 = call double @llvm.fmuladd.f64(double %399, double %402, double %396)
%404 = load double*, double** %3
%405 = getelementptr inbounds double, double* %404, i64 4
%406 = load double, double* %405
%407 = load double*, double** %4
%408 = getelementptr inbounds double, double* %407, i64 6
%409 = load double, double* %408
%410 = call double @llvm.fmuladd.f64(double %406, double %409, double %403)
%411 = fmul double 2.000000e+00, %410
%412 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 5
store double %411, double* %412
%413 = load double*, double** %3
%414 = getelementptr inbounds double, double* %413, i64 1
%415 = load double, double* %414
%416 = load double*, double** %4
%417 = getelementptr inbounds double, double* %416, i64 0
%418 = load double, double* %417
%419 = load double*, double** %3
%420 = getelementptr inbounds double, double* %419, i64 0
%421 = load double, double* %420
%422 = load double*, double** %4
%423 = getelementptr inbounds double, double* %422, i64 1
%424 = load double, double* %423
%425 = fmul double %421, %424
%426 = call double @llvm.fmuladd.f64(double %415, double %418, double %425)
%427 = load double*, double** %3
%428 = getelementptr inbounds double, double* %427, i64 2
%429 = load double, double* %428
%430 = load double*, double** %4
%431 = getelementptr inbounds double, double* %430, i64 2
%432 = load double, double* %431
%433 = call double @llvm.fmuladd.f64(double %429, double %432, double %426)
%434 = load double*, double** %3
%435 = getelementptr inbounds double, double* %434, i64 3
%436 = load double, double* %435
%437 = load double*, double** %4
%438 = getelementptr inbounds double, double* %437, i64 3
%439 = load double, double* %438
%440 = call double @llvm.fmuladd.f64(double %436, double %439, double %433)
%441 = load double*, double** %3
%442 = getelementptr inbounds double, double* %441, i64 5
%443 = load double, double* %442
%444 = load double*, double** %4
%445 = getelementptr inbounds double, double* %444, i64 4
%446 = load double, double* %445
%447 = call double @llvm.fmuladd.f64(double %443, double %446, double %440)
%448 = load double*, double** %3
%449 = getelementptr inbounds double, double* %448, i64 4
%450 = load double, double* %449
%451 = load double*, double** %4
%452 = getelementptr inbounds double, double* %451, i64 5
%453 = load double, double* %452
%454 = call double @llvm.fmuladd.f64(double %450, double %453, double %447)
%455 = load double*, double** %3
%456 = getelementptr inbounds double, double* %455, i64 6
%457 = load double, double* %456
%458 = load double*, double** %4
%459 = getelementptr inbounds double, double* %458, i64 6
%460 = load double, double* %459
%461 = call double @llvm.fmuladd.f64(double %457, double %460, double %454)
%462 = fmul double 2.000000e+00, %461
%463 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 6
store double %462, double* %463
%464 = load double*, double** %3
%465 = getelementptr inbounds double, double* %464, i64 1
%466 = load double, double* %465
%467 = load double*, double** %4
%468 = getelementptr inbounds double, double* %467, i64 0
%469 = load double, double* %468
%470 = load double*, double** %3
%471 = getelementptr inbounds double, double* %470, i64 0
%472 = load double, double* %471
%473 = load double*, double** %4
%474 = getelementptr inbounds double, double* %473, i64 1
%475 = load double, double* %474
%476 = fmul double %472, %475
%477 = call double @llvm.fmuladd.f64(double %466, double %469, double %476)
%478 = load double*, double** %3
%479 = getelementptr inbounds double, double* %478, i64 3
%480 = load double, double* %479
%481 = load double*, double** %4
%482 = getelementptr inbounds double, double* %481, i64 2
%483 = load double, double* %482
%484 = call double @llvm.fmuladd.f64(double %480, double %483, double %477)
%485 = load double*, double** %3
%486 = getelementptr inbounds double, double* %485, i64 2
%487 = load double, double* %486
%488 = load double*, double** %4
%489 = getelementptr inbounds double, double* %488, i64 3
%490 = load double, double* %489
%491 = call double @llvm.fmuladd.f64(double %487, double %490, double %484)
%492 = load double*, double** %3
%493 = getelementptr inbounds double, double* %492, i64 4
%494 = load double, double* %493
%495 = load double*, double** %4
%496 = getelementptr inbounds double, double* %495, i64 4
%497 = load double, double* %496
%498 = call double @llvm.fmuladd.f64(double %494, double %497, double %491)
%499 = load double*, double** %3
%500 = getelementptr inbounds double, double* %499, i64 5
%501 = load double, double* %500
%502 = load double*, double** %4
%503 = getelementptr inbounds double, double* %502, i64 5
%504 = load double, double* %503
%505 = call double @llvm.fmuladd.f64(double %501, double %504, double %498)
%506 = load double*, double** %3
%507 = getelementptr inbounds double, double* %506, i64 6
%508 = load double, double* %507
%509 = load double*, double** %4
%510 = getelementptr inbounds double, double* %509, i64 6
%511 = load double, double* %510
%512 = call double @llvm.fmuladd.f64(double %508, double %511, double %505)
%513 = fmul double 2.000000e+00, %512
%514 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 7
store double %513, double* %514
%515 = load double*, double** %3
%516 = getelementptr inbounds double, double* %515, i64 1
%517 = load double, double* %516
%518 = load double*, double** %4
%519 = getelementptr inbounds double, double* %518, i64 0
%520 = load double, double* %519
%521 = load double*, double** %3
%522 = getelementptr inbounds double, double* %521, i64 2
%523 = load double, double* %522
%524 = load double*, double** %4
%525 = getelementptr inbounds double, double* %524, i64 1
%526 = load double, double* %525
%527 = fmul double %523, %526
%528 = call double @llvm.fmuladd.f64(double %517, double %520, double %527)
%529 = load double*, double** %3
%530 = getelementptr inbounds double, double* %529, i64 0
%531 = load double, double* %530
%532 = load double*, double** %4
%533 = getelementptr inbounds double, double* %532, i64 2
%534 = load double, double* %533
%535 = call double @llvm.fmuladd.f64(double %531, double %534, double %528)
%536 = load double*, double** %3
%537 = getelementptr inbounds double, double* %536, i64 3
%538 = load double, double* %537
%539 = load double*, double** %4
%540 = getelementptr inbounds double, double* %539, i64 3
%541 = load double, double* %540
%542 = call double @llvm.fmuladd.f64(double %538, double %541, double %535)
%543 = load double*, double** %3
%544 = getelementptr inbounds double, double* %543, i64 5
%545 = load double, double* %544
%546 = load double*, double** %4
%547 = getelementptr inbounds double, double* %546, i64 4
%548 = load double, double* %547
%549 = call double @llvm.fmuladd.f64(double %545, double %548, double %542)
%550 = load double*, double** %3
%551 = getelementptr inbounds double, double* %550, i64 6
%552 = load double, double* %551
%553 = load double*, double** %4
%554 = getelementptr inbounds double, double* %553, i64 5
%555 = load double, double* %554
%556 = call double @llvm.fmuladd.f64(double %552, double %555, double %549)
%557 = load double*, double** %3
%558 = getelementptr inbounds double, double* %557, i64 4
%559 = load double, double* %558
%560 = load double*, double** %4
%561 = getelementptr inbounds double, double* %560, i64 6
%562 = load double, double* %561
%563 = call double @llvm.fmuladd.f64(double %559, double %562, double %556)
%564 = fmul double 2.000000e+00, %563
%565 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 8
store double %564, double* %565
%566 = load double*, double** %3
%567 = getelementptr inbounds double, double* %566, i64 1
%568 = load double, double* %567
%569 = load double*, double** %4
%570 = getelementptr inbounds double, double* %569, i64 0
%571 = load double, double* %570
%572 = load double*, double** %3
%573 = getelementptr inbounds double, double* %572, i64 2
%574 = load double, double* %573
%575 = load double*, double** %4
%576 = getelementptr inbounds double, double* %575, i64 1
%577 = load double, double* %576
%578 = fmul double %574, %577
%579 = call double @llvm.fmuladd.f64(double %568, double %571, double %578)
%580 = load double*, double** %3
%581 = getelementptr inbounds double, double* %580, i64 3
%582 = load double, double* %581
%583 = load double*, double** %4
%584 = getelementptr inbounds double, double* %583, i64 2
%585 = load double, double* %584
%586 = call double @llvm.fmuladd.f64(double %582, double %585, double %579)
%587 = load double*, double** %3
%588 = getelementptr inbounds double, double* %587, i64 0
%589 = load double, double* %588
%590 = load double*, double** %4
%591 = getelementptr inbounds double, double* %590, i64 3
%592 = load double, double* %591
%593 = call double @llvm.fmuladd.f64(double %589, double %592, double %586)
%594 = load double*, double** %3
%595 = getelementptr inbounds double, double* %594, i64 6
%596 = load double, double* %595
%597 = load double*, double** %4
%598 = getelementptr inbounds double, double* %597, i64 4
%599 = load double, double* %598
%600 = call double @llvm.fmuladd.f64(double %596, double %599, double %593)
%601 = load double*, double** %3
%602 = getelementptr inbounds double, double* %601, i64 5
%603 = load double, double* %602
%604 = load double*, double** %4
%605 = getelementptr inbounds double, double* %604, i64 5
%606 = load double, double* %605
%607 = call double @llvm.fmuladd.f64(double %603, double %606, double %600)
%608 = load double*, double** %3
%609 = getelementptr inbounds double, double* %608, i64 4
%610 = load double, double* %609
%611 = load double*, double** %4
%612 = getelementptr inbounds double, double* %611, i64 6
%613 = load double, double* %612
%614 = call double @llvm.fmuladd.f64(double %610, double %613, double %607)
%615 = fmul double 2.000000e+00, %614
%616 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 9
store double %615, double* %616
%617 = load double*, double** %3
%618 = getelementptr inbounds double, double* %617, i64 1
%619 = load double, double* %618
%620 = load double*, double** %4
%621 = getelementptr inbounds double, double* %620, i64 0
%622 = load double, double* %621
%623 = load double*, double** %3
%624 = getelementptr inbounds double, double* %623, i64 3
%625 = load double, double* %624
%626 = load double*, double** %4
%627 = getelementptr inbounds double, double* %626, i64 1
%628 = load double, double* %627
%629 = fmul double %625, %628
%630 = call double @llvm.fmuladd.f64(double %619, double %622, double %629)
%631 = load double*, double** %3
%632 = getelementptr inbounds double, double* %631, i64 0
%633 = load double, double* %632
%634 = load double*, double** %4
%635 = getelementptr inbounds double, double* %634, i64 2
%636 = load double, double* %635
%637 = call double @llvm.fmuladd.f64(double %633, double %636, double %630)
%638 = load double*, double** %3
%639 = getelementptr inbounds double, double* %638, i64 2
%640 = load double, double* %639
%641 = load double*, double** %4
%642 = getelementptr inbounds double, double* %641, i64 3
%643 = load double, double* %642
%644 = call double @llvm.fmuladd.f64(double %640, double %643, double %637)
%645 = load double*, double** %3
%646 = getelementptr inbounds double, double* %645, i64 4
%647 = load double, double* %646
%648 = load double*, double** %4
%649 = getelementptr inbounds double, double* %648, i64 4
%650 = load double, double* %649
%651 = call double @llvm.fmuladd.f64(double %647, double %650, double %644)
%652 = load double*, double** %3
%653 = getelementptr inbounds double, double* %652, i64 6
%654 = load double, double* %653
%655 = load double*, double** %4
%656 = getelementptr inbounds double, double* %655, i64 5
%657 = load double, double* %656
%658 = call double @llvm.fmuladd.f64(double %654, double %657, double %651)
%659 = load double*, double** %3
%660 = getelementptr inbounds double, double* %659, i64 5
%661 = load double, double* %660
%662 = load double*, double** %4
%663 = getelementptr inbounds double, double* %662, i64 6
%664 = load double, double* %663
%665 = call double @llvm.fmuladd.f64(double %661, double %664, double %658)
%666 = fmul double 2.000000e+00, %665
%667 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 10
store double %666, double* %667
%668 = load double*, double** %3
%669 = getelementptr inbounds double, double* %668, i64 1
%670 = load double, double* %669
%671 = load double*, double** %4
%672 = getelementptr inbounds double, double* %671, i64 0
%673 = load double, double* %672
%674 = load double*, double** %3
%675 = getelementptr inbounds double, double* %674, i64 3
%676 = load double, double* %675
%677 = load double*, double** %4
%678 = getelementptr inbounds double, double* %677, i64 1
%679 = load double, double* %678
%680 = fmul double %676, %679
%681 = call double @llvm.fmuladd.f64(double %670, double %673, double %680)
%682 = load double*, double** %3
%683 = getelementptr inbounds double, double* %682, i64 2
%684 = load double, double* %683
%685 = load double*, double** %4
%686 = getelementptr inbounds double, double* %685, i64 2
%687 = load double, double* %686
%688 = call double @llvm.fmuladd.f64(double %684, double %687, double %681)
%689 = load double*, double** %3
%690 = getelementptr inbounds double, double* %689, i64 0
%691 = load double, double* %690
%692 = load double*, double** %4
%693 = getelementptr inbounds double, double* %692, i64 3
%694 = load double, double* %693
%695 = call double @llvm.fmuladd.f64(double %691, double %694, double %688)
%696 = load double*, double** %3
%697 = getelementptr inbounds double, double* %696, i64 6
%698 = load double, double* %697
%699 = load double*, double** %4
%700 = getelementptr inbounds double, double* %699, i64 4
%701 = load double, double* %700
%702 = call double @llvm.fmuladd.f64(double %698, double %701, double %695)
%703 = load double*, double** %3
%704 = getelementptr inbounds double, double* %703, i64 4
%705 = load double, double* %704
%706 = load double*, double** %4
%707 = getelementptr inbounds double, double* %706, i64 5
%708 = load double, double* %707
%709 = call double @llvm.fmuladd.f64(double %705, double %708, double %702)
%710 = load double*, double** %3
%711 = getelementptr inbounds double, double* %710, i64 5
%712 = load double, double* %711
%713 = load double*, double** %4
%714 = getelementptr inbounds double, double* %713, i64 6
%715 = load double, double* %714
%716 = call double @llvm.fmuladd.f64(double %712, double %715, double %709)
%717 = fmul double 2.000000e+00, %716
%718 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 11
store double %717, double* %718
%719 = load double*, double** %3
%720 = getelementptr inbounds double, double* %719, i64 2
%721 = load double, double* %720
%722 = load double*, double** %4
%723 = getelementptr inbounds double, double* %722, i64 0
%724 = load double, double* %723
%725 = load double*, double** %3
%726 = getelementptr inbounds double, double* %725, i64 0
%727 = load double, double* %726
%728 = load double*, double** %4
%729 = getelementptr inbounds double, double* %728, i64 1
%730 = load double, double* %729
%731 = fmul double %727, %730
%732 = call double @llvm.fmuladd.f64(double %721, double %724, double %731)
%733 = load double*, double** %3
%734 = getelementptr inbounds double, double* %733, i64 1
%735 = load double, double* %734
%736 = load double*, double** %4
%737 = getelementptr inbounds double, double* %736, i64 2
%738 = load double, double* %737
%739 = call double @llvm.fmuladd.f64(double %735, double %738, double %732)
%740 = load double*, double** %3
%741 = getelementptr inbounds double, double* %740, i64 3
%742 = load double, double* %741
%743 = load double*, double** %4
%744 = getelementptr inbounds double, double* %743, i64 3
%745 = load double, double* %744
%746 = call double @llvm.fmuladd.f64(double %742, double %745, double %739)
%747 = load double*, double** %3
%748 = getelementptr inbounds double, double* %747, i64 6
%749 = load double, double* %748
%750 = load double*, double** %4
%751 = getelementptr inbounds double, double* %750, i64 4
%752 = load double, double* %751
%753 = call double @llvm.fmuladd.f64(double %749, double %752, double %746)
%754 = load double*, double** %3
%755 = getelementptr inbounds double, double* %754, i64 4
%756 = load double, double* %755
%757 = load double*, double** %4
%758 = getelementptr inbounds double, double* %757, i64 5
%759 = load double, double* %758
%760 = call double @llvm.fmuladd.f64(double %756, double %759, double %753)
%761 = load double*, double** %3
%762 = getelementptr inbounds double, double* %761, i64 5
%763 = load double, double* %762
%764 = load double*, double** %4
%765 = getelementptr inbounds double, double* %764, i64 6
%766 = load double, double* %765
%767 = call double @llvm.fmuladd.f64(double %763, double %766, double %760)
%768 = fmul double 2.000000e+00, %767
%769 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 12
store double %768, double* %769
%770 = load double*, double** %3
%771 = getelementptr inbounds double, double* %770, i64 2
%772 = load double, double* %771
%773 = load double*, double** %4
%774 = getelementptr inbounds double, double* %773, i64 0
%775 = load double, double* %774
%776 = load double*, double** %3
%777 = getelementptr inbounds double, double* %776, i64 0
%778 = load double, double* %777
%779 = load double*, double** %4
%780 = getelementptr inbounds double, double* %779, i64 1
%781 = load double, double* %780
%782 = fmul double %778, %781
%783 = call double @llvm.fmuladd.f64(double %772, double %775, double %782)
%784 = load double*, double** %3
%785 = getelementptr inbounds double, double* %784, i64 3
%786 = load double, double* %785
%787 = load double*, double** %4
%788 = getelementptr inbounds double, double* %787, i64 2
%789 = load double, double* %788
%790 = call double @llvm.fmuladd.f64(double %786, double %789, double %783)
%791 = load double*, double** %3
%792 = getelementptr inbounds double, double* %791, i64 1
%793 = load double, double* %792
%794 = load double*, double** %4
%795 = getelementptr inbounds double, double* %794, i64 3
%796 = load double, double* %795
%797 = call double @llvm.fmuladd.f64(double %793, double %796, double %790)
%798 = load double*, double** %3
%799 = getelementptr inbounds double, double* %798, i64 4
%800 = load double, double* %799
%801 = load double*, double** %4
%802 = getelementptr inbounds double, double* %801, i64 4
%803 = load double, double* %802
%804 = call double @llvm.fmuladd.f64(double %800, double %803, double %797)
%805 = load double*, double** %3
%806 = getelementptr inbounds double, double* %805, i64 6
%807 = load double, double* %806
%808 = load double*, double** %4
%809 = getelementptr inbounds double, double* %808, i64 5
%810 = load double, double* %809
%811 = call double @llvm.fmuladd.f64(double %807, double %810, double %804)
%812 = load double*, double** %3
%813 = getelementptr inbounds double, double* %812, i64 5
%814 = load double, double* %813
%815 = load double*, double** %4
%816 = getelementptr inbounds double, double* %815, i64 6
%817 = load double, double* %816
%818 = call double @llvm.fmuladd.f64(double %814, double %817, double %811)
%819 = fmul double 2.000000e+00, %818
%820 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 13
store double %819, double* %820
%821 = load double*, double** %3
%822 = getelementptr inbounds double, double* %821, i64 2
%823 = load double, double* %822
%824 = load double*, double** %4
%825 = getelementptr inbounds double, double* %824, i64 0
%826 = load double, double* %825
%827 = load double*, double** %3
%828 = getelementptr inbounds double, double* %827, i64 1
%829 = load double, double* %828
%830 = load double*, double** %4
%831 = getelementptr inbounds double, double* %830, i64 1
%832 = load double, double* %831
%833 = fmul double %829, %832
%834 = call double @llvm.fmuladd.f64(double %823, double %826, double %833)
%835 = load double*, double** %3
%836 = getelementptr inbounds double, double* %835, i64 0
%837 = load double, double* %836
%838 = load double*, double** %4
%839 = getelementptr inbounds double, double* %838, i64 2
%840 = load double, double* %839
%841 = call double @llvm.fmuladd.f64(double %837, double %840, double %834)
%842 = load double*, double** %3
%843 = getelementptr inbounds double, double* %842, i64 3
%844 = load double, double* %843
%845 = load double*, double** %4
%846 = getelementptr inbounds double, double* %845, i64 3
%847 = load double, double* %846
%848 = call double @llvm.fmuladd.f64(double %844, double %847, double %841)
%849 = load double*, double** %3
%850 = getelementptr inbounds double, double* %849, i64 6
%851 = load double, double* %850
%852 = load double*, double** %4
%853 = getelementptr inbounds double, double* %852, i64 4
%854 = load double, double* %853
%855 = call double @llvm.fmuladd.f64(double %851, double %854, double %848)
%856 = load double*, double** %3
%857 = getelementptr inbounds double, double* %856, i64 5
%858 = load double, double* %857
%859 = load double*, double** %4
%860 = getelementptr inbounds double, double* %859, i64 5
%861 = load double, double* %860
%862 = call double @llvm.fmuladd.f64(double %858, double %861, double %855)
%863 = load double*, double** %3
%864 = getelementptr inbounds double, double* %863, i64 4
%865 = load double, double* %864
%866 = load double*, double** %4
%867 = getelementptr inbounds double, double* %866, i64 6
%868 = load double, double* %867
%869 = call double @llvm.fmuladd.f64(double %865, double %868, double %862)
%870 = fmul double 2.000000e+00, %869
%871 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 14
store double %870, double* %871
%872 = load double*, double** %3
%873 = getelementptr inbounds double, double* %872, i64 2
%874 = load double, double* %873
%875 = load double*, double** %4
%876 = getelementptr inbounds double, double* %875, i64 0
%877 = load double, double* %876
%878 = load double*, double** %3
%879 = getelementptr inbounds double, double* %878, i64 1
%880 = load double, double* %879
%881 = load double*, double** %4
%882 = getelementptr inbounds double, double* %881, i64 1
%883 = load double, double* %882
%884 = fmul double %880, %883
%885 = call double @llvm.fmuladd.f64(double %874, double %877, double %884)
%886 = load double*, double** %3
%887 = getelementptr inbounds double, double* %886, i64 3
%888 = load double, double* %887
%889 = load double*, double** %4
%890 = getelementptr inbounds double, double* %889, i64 2
%891 = load double, double* %890
%892 = call double @llvm.fmuladd.f64(double %888, double %891, double %885)
%893 = load double*, double** %3
%894 = getelementptr inbounds double, double* %893, i64 0
%895 = load double, double* %894
%896 = load double*, double** %4
%897 = getelementptr inbounds double, double* %896, i64 3
%898 = load double, double* %897
%899 = call double @llvm.fmuladd.f64(double %895, double %898, double %892)
%900 = load double*, double** %3
%901 = getelementptr inbounds double, double* %900, i64 5
%902 = load double, double* %901
%903 = load double*, double** %4
%904 = getelementptr inbounds double, double* %903, i64 4
%905 = load double, double* %904
%906 = call double @llvm.fmuladd.f64(double %902, double %905, double %899)
%907 = load double*, double** %3
%908 = getelementptr inbounds double, double* %907, i64 6
%909 = load double, double* %908
%910 = load double*, double** %4
%911 = getelementptr inbounds double, double* %910, i64 5
%912 = load double, double* %911
%913 = call double @llvm.fmuladd.f64(double %909, double %912, double %906)
%914 = load double*, double** %3
%915 = getelementptr inbounds double, double* %914, i64 4
%916 = load double, double* %915
%917 = load double*, double** %4
%918 = getelementptr inbounds double, double* %917, i64 6
%919 = load double, double* %918
%920 = call double @llvm.fmuladd.f64(double %916, double %919, double %913)
%921 = fmul double 2.000000e+00, %920
%922 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 15
store double %921, double* %922
%923 = load double*, double** %3
%924 = getelementptr inbounds double, double* %923, i64 2
%925 = load double, double* %924
%926 = load double*, double** %4
%927 = getelementptr inbounds double, double* %926, i64 0
%928 = load double, double* %927
%929 = load double*, double** %3
%930 = getelementptr inbounds double, double* %929, i64 3
%931 = load double, double* %930
%932 = load double*, double** %4
%933 = getelementptr inbounds double, double* %932, i64 1
%934 = load double, double* %933
%935 = fmul double %931, %934
%936 = call double @llvm.fmuladd.f64(double %925, double %928, double %935)
%937 = load double*, double** %3
%938 = getelementptr inbounds double, double* %937, i64 0
%939 = load double, double* %938
%940 = load double*, double** %4
%941 = getelementptr inbounds double, double* %940, i64 2
%942 = load double, double* %941
%943 = call double @llvm.fmuladd.f64(double %939, double %942, double %936)
%944 = load double*, double** %3
%945 = getelementptr inbounds double, double* %944, i64 1
%946 = load double, double* %945
%947 = load double*, double** %4
%948 = getelementptr inbounds double, double* %947, i64 3
%949 = load double, double* %948
%950 = call double @llvm.fmuladd.f64(double %946, double %949, double %943)
%951 = load double*, double** %3
%952 = getelementptr inbounds double, double* %951, i64 4
%953 = load double, double* %952
%954 = load double*, double** %4
%955 = getelementptr inbounds double, double* %954, i64 4
%956 = load double, double* %955
%957 = call double @llvm.fmuladd.f64(double %953, double %956, double %950)
%958 = load double*, double** %3
%959 = getelementptr inbounds double, double* %958, i64 5
%960 = load double, double* %959
%961 = load double*, double** %4
%962 = getelementptr inbounds double, double* %961, i64 5
%963 = load double, double* %962
%964 = call double @llvm.fmuladd.f64(double %960, double %963, double %957)
%965 = load double*, double** %3
%966 = getelementptr inbounds double, double* %965, i64 6
%967 = load double, double* %966
%968 = load double*, double** %4
%969 = getelementptr inbounds double, double* %968, i64 6
%970 = load double, double* %969
%971 = call double @llvm.fmuladd.f64(double %967, double %970, double %964)
%972 = fmul double 2.000000e+00, %971
%973 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 16
store double %972, double* %973
%974 = load double*, double** %3
%975 = getelementptr inbounds double, double* %974, i64 2
%976 = load double, double* %975
%977 = load double*, double** %4
%978 = getelementptr inbounds double, double* %977, i64 0
%979 = load double, double* %978
%980 = load double*, double** %3
%981 = getelementptr inbounds double, double* %980, i64 3
%982 = load double, double* %981
%983 = load double*, double** %4
%984 = getelementptr inbounds double, double* %983, i64 1
%985 = load double, double* %984
%986 = fmul double %982, %985
%987 = call double @llvm.fmuladd.f64(double %976, double %979, double %986)
%988 = load double*, double** %3
%989 = getelementptr inbounds double, double* %988, i64 1
%990 = load double, double* %989
%991 = load double*, double** %4
%992 = getelementptr inbounds double, double* %991, i64 2
%993 = load double, double* %992
%994 = call double @llvm.fmuladd.f64(double %990, double %993, double %987)
%995 = load double*, double** %3
%996 = getelementptr inbounds double, double* %995, i64 0
%997 = load double, double* %996
%998 = load double*, double** %4
%999 = getelementptr inbounds double, double* %998, i64 3
%1000 = load double, double* %999
%1001 = call double @llvm.fmuladd.f64(double %997, double %1000, double %994)
%1002 = load double*, double** %3
%1003 = getelementptr inbounds double, double* %1002, i64 5
%1004 = load double, double* %1003
%1005 = load double*, double** %4
%1006 = getelementptr inbounds double, double* %1005, i64 4
%1007 = load double, double* %1006
%1008 = call double @llvm.fmuladd.f64(double %1004, double %1007, double %1001)
%1009 = load double*, double** %3
%1010 = getelementptr inbounds double, double* %1009, i64 4
%1011 = load double, double* %1010
%1012 = load double*, double** %4
%1013 = getelementptr inbounds double, double* %1012, i64 5
%1014 = load double, double* %1013
%1015 = call double @llvm.fmuladd.f64(double %1011, double %1014, double %1008)
%1016 = load double*, double** %3
%1017 = getelementptr inbounds double, double* %1016, i64 6
%1018 = load double, double* %1017
%1019 = load double*, double** %4
%1020 = getelementptr inbounds double, double* %1019, i64 6
%1021 = load double, double* %1020
%1022 = call double @llvm.fmuladd.f64(double %1018, double %1021, double %1015)
%1023 = fmul double 2.000000e+00, %1022
%1024 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 17
store double %1023, double* %1024
%1025 = load double*, double** %3
%1026 = getelementptr inbounds double, double* %1025, i64 3
%1027 = load double, double* %1026
%1028 = load double*, double** %4
%1029 = getelementptr inbounds double, double* %1028, i64 0
%1030 = load double, double* %1029
%1031 = load double*, double** %3
%1032 = getelementptr inbounds double, double* %1031, i64 0
%1033 = load double, double* %1032
%1034 = load double*, double** %4
%1035 = getelementptr inbounds double, double* %1034, i64 1
%1036 = load double, double* %1035
%1037 = fmul double %1033, %1036
%1038 = call double @llvm.fmuladd.f64(double %1027, double %1030, double %1037)
%1039 = load double*, double** %3
%1040 = getelementptr inbounds double, double* %1039, i64 1
%1041 = load double, double* %1040
%1042 = load double*, double** %4
%1043 = getelementptr inbounds double, double* %1042, i64 2
%1044 = load double, double* %1043
%1045 = call double @llvm.fmuladd.f64(double %1041, double %1044, double %1038)
%1046 = load double*, double** %3
%1047 = getelementptr inbounds double, double* %1046, i64 2
%1048 = load double, double* %1047
%1049 = load double*, double** %4
%1050 = getelementptr inbounds double, double* %1049, i64 3
%1051 = load double, double* %1050
%1052 = call double @llvm.fmuladd.f64(double %1048, double %1051, double %1045)
%1053 = load double*, double** %3
%1054 = getelementptr inbounds double, double* %1053, i64 6
%1055 = load double, double* %1054
%1056 = load double*, double** %4
%1057 = getelementptr inbounds double, double* %1056, i64 4
%1058 = load double, double* %1057
%1059 = call double @llvm.fmuladd.f64(double %1055, double %1058, double %1052)
%1060 = load double*, double** %3
%1061 = getelementptr inbounds double, double* %1060, i64 5
%1062 = load double, double* %1061
%1063 = load double*, double** %4
%1064 = getelementptr inbounds double, double* %1063, i64 5
%1065 = load double, double* %1064
%1066 = call double @llvm.fmuladd.f64(double %1062, double %1065, double %1059)
%1067 = load double*, double** %3
%1068 = getelementptr inbounds double, double* %1067, i64 4
%1069 = load double, double* %1068
%1070 = load double*, double** %4
%1071 = getelementptr inbounds double, double* %1070, i64 6
%1072 = load double, double* %1071
%1073 = call double @llvm.fmuladd.f64(double %1069, double %1072, double %1066)
%1074 = fmul double 2.000000e+00, %1073
%1075 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 18
store double %1074, double* %1075
%1076 = load double*, double** %3
%1077 = getelementptr inbounds double, double* %1076, i64 3
%1078 = load double, double* %1077
%1079 = load double*, double** %4
%1080 = getelementptr inbounds double, double* %1079, i64 0
%1081 = load double, double* %1080
%1082 = load double*, double** %3
%1083 = getelementptr inbounds double, double* %1082, i64 0
%1084 = load double, double* %1083
%1085 = load double*, double** %4
%1086 = getelementptr inbounds double, double* %1085, i64 1
%1087 = load double, double* %1086
%1088 = fmul double %1084, %1087
%1089 = call double @llvm.fmuladd.f64(double %1078, double %1081, double %1088)
%1090 = load double*, double** %3
%1091 = getelementptr inbounds double, double* %1090, i64 2
%1092 = load double, double* %1091
%1093 = load double*, double** %4
%1094 = getelementptr inbounds double, double* %1093, i64 2
%1095 = load double, double* %1094
%1096 = call double @llvm.fmuladd.f64(double %1092, double %1095, double %1089)
%1097 = load double*, double** %3
%1098 = getelementptr inbounds double, double* %1097, i64 1
%1099 = load double, double* %1098
%1100 = load double*, double** %4
%1101 = getelementptr inbounds double, double* %1100, i64 3
%1102 = load double, double* %1101
%1103 = call double @llvm.fmuladd.f64(double %1099, double %1102, double %1096)
%1104 = load double*, double** %3
%1105 = getelementptr inbounds double, double* %1104, i64 5
%1106 = load double, double* %1105
%1107 = load double*, double** %4
%1108 = getelementptr inbounds double, double* %1107, i64 4
%1109 = load double, double* %1108
%1110 = call double @llvm.fmuladd.f64(double %1106, double %1109, double %1103)
%1111 = load double*, double** %3
%1112 = getelementptr inbounds double, double* %1111, i64 6
%1113 = load double, double* %1112
%1114 = load double*, double** %4
%1115 = getelementptr inbounds double, double* %1114, i64 5
%1116 = load double, double* %1115
%1117 = call double @llvm.fmuladd.f64(double %1113, double %1116, double %1110)
%1118 = load double*, double** %3
%1119 = getelementptr inbounds double, double* %1118, i64 4
%1120 = load double, double* %1119
%1121 = load double*, double** %4
%1122 = getelementptr inbounds double, double* %1121, i64 6
%1123 = load double, double* %1122
%1124 = call double @llvm.fmuladd.f64(double %1120, double %1123, double %1117)
%1125 = fmul double 2.000000e+00, %1124
%1126 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 19
store double %1125, double* %1126
%1127 = load double*, double** %3
%1128 = getelementptr inbounds double, double* %1127, i64 3
%1129 = load double, double* %1128
%1130 = load double*, double** %4
%1131 = getelementptr inbounds double, double* %1130, i64 0
%1132 = load double, double* %1131
%1133 = load double*, double** %3
%1134 = getelementptr inbounds double, double* %1133, i64 1
%1135 = load double, double* %1134
%1136 = load double*, double** %4
%1137 = getelementptr inbounds double, double* %1136, i64 1
%1138 = load double, double* %1137
%1139 = fmul double %1135, %1138
%1140 = call double @llvm.fmuladd.f64(double %1129, double %1132, double %1139)
%1141 = load double*, double** %3
%1142 = getelementptr inbounds double, double* %1141, i64 0
%1143 = load double, double* %1142
%1144 = load double*, double** %4
%1145 = getelementptr inbounds double, double* %1144, i64 2
%1146 = load double, double* %1145
%1147 = call double @llvm.fmuladd.f64(double %1143, double %1146, double %1140)
%1148 = load double*, double** %3
%1149 = getelementptr inbounds double, double* %1148, i64 2
%1150 = load double, double* %1149
%1151 = load double*, double** %4
%1152 = getelementptr inbounds double, double* %1151, i64 3
%1153 = load double, double* %1152
%1154 = call double @llvm.fmuladd.f64(double %1150, double %1153, double %1147)
%1155 = load double*, double** %3
%1156 = getelementptr inbounds double, double* %1155, i64 6
%1157 = load double, double* %1156
%1158 = load double*, double** %4
%1159 = getelementptr inbounds double, double* %1158, i64 4
%1160 = load double, double* %1159
%1161 = call double @llvm.fmuladd.f64(double %1157, double %1160, double %1154)
%1162 = load double*, double** %3
%1163 = getelementptr inbounds double, double* %1162, i64 4
%1164 = load double, double* %1163
%1165 = load double*, double** %4
%1166 = getelementptr inbounds double, double* %1165, i64 5
%1167 = load double, double* %1166
%1168 = call double @llvm.fmuladd.f64(double %1164, double %1167, double %1161)
%1169 = load double*, double** %3
%1170 = getelementptr inbounds double, double* %1169, i64 5
%1171 = load double, double* %1170
%1172 = load double*, double** %4
%1173 = getelementptr inbounds double, double* %1172, i64 6
%1174 = load double, double* %1173
%1175 = call double @llvm.fmuladd.f64(double %1171, double %1174, double %1168)
%1176 = fmul double 2.000000e+00, %1175
%1177 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 20
store double %1176, double* %1177
%1178 = load double*, double** %3
%1179 = getelementptr inbounds double, double* %1178, i64 3
%1180 = load double, double* %1179
%1181 = load double*, double** %4
%1182 = getelementptr inbounds double, double* %1181, i64 0
%1183 = load double, double* %1182
%1184 = load double*, double** %3
%1185 = getelementptr inbounds double, double* %1184, i64 1
%1186 = load double, double* %1185
%1187 = load double*, double** %4
%1188 = getelementptr inbounds double, double* %1187, i64 1
%1189 = load double, double* %1188
%1190 = fmul double %1186, %1189
%1191 = call double @llvm.fmuladd.f64(double %1180, double %1183, double %1190)
%1192 = load double*, double** %3
%1193 = getelementptr inbounds double, double* %1192, i64 2
%1194 = load double, double* %1193
%1195 = load double*, double** %4
%1196 = getelementptr inbounds double, double* %1195, i64 2
%1197 = load double, double* %1196
%1198 = call double @llvm.fmuladd.f64(double %1194, double %1197, double %1191)
%1199 = load double*, double** %3
%1200 = getelementptr inbounds double, double* %1199, i64 0
%1201 = load double, double* %1200
%1202 = load double*, double** %4
%1203 = getelementptr inbounds double, double* %1202, i64 3
%1204 = load double, double* %1203
%1205 = call double @llvm.fmuladd.f64(double %1201, double %1204, double %1198)
%1206 = load double*, double** %3
%1207 = getelementptr inbounds double, double* %1206, i64 4
%1208 = load double, double* %1207
%1209 = load double*, double** %4
%1210 = getelementptr inbounds double, double* %1209, i64 4
%1211 = load double, double* %1210
%1212 = call double @llvm.fmuladd.f64(double %1208, double %1211, double %1205)
%1213 = load double*, double** %3
%1214 = getelementptr inbounds double, double* %1213, i64 6
%1215 = load double, double* %1214
%1216 = load double*, double** %4
%1217 = getelementptr inbounds double, double* %1216, i64 5
%1218 = load double, double* %1217
%1219 = call double @llvm.fmuladd.f64(double %1215, double %1218, double %1212)
%1220 = load double*, double** %3
%1221 = getelementptr inbounds double, double* %1220, i64 5
%1222 = load double, double* %1221
%1223 = load double*, double** %4
%1224 = getelementptr inbounds double, double* %1223, i64 6
%1225 = load double, double* %1224
%1226 = call double @llvm.fmuladd.f64(double %1222, double %1225, double %1219)
%1227 = fmul double 2.000000e+00, %1226
%1228 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 21
store double %1227, double* %1228
%1229 = load double*, double** %3
%1230 = getelementptr inbounds double, double* %1229, i64 3
%1231 = load double, double* %1230
%1232 = load double*, double** %4
%1233 = getelementptr inbounds double, double* %1232, i64 0
%1234 = load double, double* %1233
%1235 = load double*, double** %3
%1236 = getelementptr inbounds double, double* %1235, i64 2
%1237 = load double, double* %1236
%1238 = load double*, double** %4
%1239 = getelementptr inbounds double, double* %1238, i64 1
%1240 = load double, double* %1239
%1241 = fmul double %1237, %1240
%1242 = call double @llvm.fmuladd.f64(double %1231, double %1234, double %1241)
%1243 = load double*, double** %3
%1244 = getelementptr inbounds double, double* %1243, i64 0
%1245 = load double, double* %1244
%1246 = load double*, double** %4
%1247 = getelementptr inbounds double, double* %1246, i64 2
%1248 = load double, double* %1247
%1249 = call double @llvm.fmuladd.f64(double %1245, double %1248, double %1242)
%1250 = load double*, double** %3
%1251 = getelementptr inbounds double, double* %1250, i64 1
%1252 = load double, double* %1251
%1253 = load double*, double** %4
%1254 = getelementptr inbounds double, double* %1253, i64 3
%1255 = load double, double* %1254
%1256 = call double @llvm.fmuladd.f64(double %1252, double %1255, double %1249)
%1257 = load double*, double** %3
%1258 = getelementptr inbounds double, double* %1257, i64 5
%1259 = load double, double* %1258
%1260 = load double*, double** %4
%1261 = getelementptr inbounds double, double* %1260, i64 4
%1262 = load double, double* %1261
%1263 = call double @llvm.fmuladd.f64(double %1259, double %1262, double %1256)
%1264 = load double*, double** %3
%1265 = getelementptr inbounds double, double* %1264, i64 4
%1266 = load double, double* %1265
%1267 = load double*, double** %4
%1268 = getelementptr inbounds double, double* %1267, i64 5
%1269 = load double, double* %1268
%1270 = call double @llvm.fmuladd.f64(double %1266, double %1269, double %1263)
%1271 = load double*, double** %3
%1272 = getelementptr inbounds double, double* %1271, i64 6
%1273 = load double, double* %1272
%1274 = load double*, double** %4
%1275 = getelementptr inbounds double, double* %1274, i64 6
%1276 = load double, double* %1275
%1277 = call double @llvm.fmuladd.f64(double %1273, double %1276, double %1270)
%1278 = fmul double 2.000000e+00, %1277
%1279 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 22
store double %1278, double* %1279
%1280 = load double*, double** %3
%1281 = getelementptr inbounds double, double* %1280, i64 3
%1282 = load double, double* %1281
%1283 = load double*, double** %4
%1284 = getelementptr inbounds double, double* %1283, i64 0
%1285 = load double, double* %1284
%1286 = load double*, double** %3
%1287 = getelementptr inbounds double, double* %1286, i64 2
%1288 = load double, double* %1287
%1289 = load double*, double** %4
%1290 = getelementptr inbounds double, double* %1289, i64 1
%1291 = load double, double* %1290
%1292 = fmul double %1288, %1291
%1293 = call double @llvm.fmuladd.f64(double %1282, double %1285, double %1292)
%1294 = load double*, double** %3
%1295 = getelementptr inbounds double, double* %1294, i64 1
%1296 = load double, double* %1295
%1297 = load double*, double** %4
%1298 = getelementptr inbounds double, double* %1297, i64 2
%1299 = load double, double* %1298
%1300 = call double @llvm.fmuladd.f64(double %1296, double %1299, double %1293)
%1301 = load double*, double** %3
%1302 = getelementptr inbounds double, double* %1301, i64 0
%1303 = load double, double* %1302
%1304 = load double*, double** %4
%1305 = getelementptr inbounds double, double* %1304, i64 3
%1306 = load double, double* %1305
%1307 = call double @llvm.fmuladd.f64(double %1303, double %1306, double %1300)
%1308 = load double*, double** %3
%1309 = getelementptr inbounds double, double* %1308, i64 4
%1310 = load double, double* %1309
%1311 = load double*, double** %4
%1312 = getelementptr inbounds double, double* %1311, i64 4
%1313 = load double, double* %1312
%1314 = call double @llvm.fmuladd.f64(double %1310, double %1313, double %1307)
%1315 = load double*, double** %3
%1316 = getelementptr inbounds double, double* %1315, i64 5
%1317 = load double, double* %1316
%1318 = load double*, double** %4
%1319 = getelementptr inbounds double, double* %1318, i64 5
%1320 = load double, double* %1319
%1321 = call double @llvm.fmuladd.f64(double %1317, double %1320, double %1314)
%1322 = load double*, double** %3
%1323 = getelementptr inbounds double, double* %1322, i64 6
%1324 = load double, double* %1323
%1325 = load double*, double** %4
%1326 = getelementptr inbounds double, double* %1325, i64 6
%1327 = load double, double* %1326
%1328 = call double @llvm.fmuladd.f64(double %1324, double %1327, double %1321)
%1329 = fmul double 2.000000e+00, %1328
%1330 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 23
store double %1329, double* %1330
%1331 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 0
%1332 = load double, double* %1331
store double %1332, double* %6
store i32 1, i32* %8
br label %1333
1333: ; preds = %1349, %2
%1334 = load i32, i32* %8
%1335 = icmp slt i32 %1334, 24
br i1 %1335, label %1336, label %1352
1336: ; preds = %1333
%1337 = load i32, i32* %8
%1338 = sext i32 %1337 to i64
%1339 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 %1338
%1340 = load double, double* %1339
%1341 = load double, double* %6
%1342 = fcmp ogt double %1340, %1341
br i1 %1342, label %1343, label %1348
1343: ; preds = %1336
%1344 = load i32, i32* %8
%1345 = sext i32 %1344 to i64
%1346 = getelementptr inbounds [24 x double], [24 x double]* %7, i64 0, i64 %1345
%1347 = load double, double* %1346
store double %1347, double* %6
br label %1348
1348: ; preds = %1343, %1336
br label %1349
1349: ; preds = %1348
%1350 = load i32, i32* %8
%1351 = add nsw i32 %1350, 1
store i32 %1351, i32* %8
br label %1333
1352: ; preds = %1333
%1353 = load double, double* %5
%1354 = load double, double* %6
%1355 = fsub double %1353, %1354
%1356 = call double @llvm.fabs.f64(double %1355)
ret double %1356
}

LLVM IR (-O2):
define double @d71234distsq(double* %0, double* %1) {
%3 = load double, double* %0
%4 = getelementptr inbounds double, double* %0, i64 1
%5 = load double, double* %4
%6 = getelementptr inbounds double, double* %0, i64 2
%7 = bitcast double* %6 to <2 x double>*
%8 = load <2 x double>, <2 x double>* %7
%9 = getelementptr inbounds double, double* %0, i64 4
%10 = bitcast double* %9 to <2 x double>*
%11 = load <2 x double>, <2 x double>* %10
%12 = getelementptr inbounds double, double* %0, i64 6
%13 = load double, double* %12
%14 = load double, double* %1
%15 = getelementptr inbounds double, double* %1, i64 1
%16 = load double, double* %15
%17 = getelementptr inbounds double, double* %1, i64 2
%18 = load double, double* %17
%19 = getelementptr inbounds double, double* %1, i64 3
%20 = load double, double* %19
%21 = getelementptr inbounds double, double* %1, i64 4
%22 = load double, double* %21
%23 = getelementptr inbounds double, double* %1, i64 5
%24 = load double, double* %23
%25 = getelementptr inbounds double, double* %1, i64 6
%26 = load double, double* %25
%27 = fmul double %5, %16
%28 = tail call double @llvm.fmuladd.f64(double %3, double %14, double %27)
%29 = insertelement <2 x double> poison, double %18, i64 0
%30 = shufflevector <2 x double> %29, <2 x double> poison, <2 x i32> zeroinitializer
%31 = insertelement <2 x double> poison, double %28, i64 0
%32 = shufflevector <2 x double> %31, <2 x double> poison, <2 x i32> zeroinitializer
%33 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %8, <2 x double> %30, <2 x double> %32)
%34 = shufflevector <2 x double> %33, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%35 = insertelement <2 x double> poison, double %20, i64 0
%36 = shufflevector <2 x double> %35, <2 x double> poison, <2 x i32> zeroinitializer
%37 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %8, <2 x double> %36, <2 x double> %34)
%38 = extractelement <2 x double> %11, i64 1
%39 = extractelement <2 x double> %11, i64 0
%40 = shufflevector <2 x double> %11, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%41 = insertelement <2 x double> poison, double %22, i64 0
%42 = shufflevector <2 x double> %41, <2 x double> poison, <2 x i32> zeroinitializer
%43 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %40, <2 x double> %42, <2 x double> %37)
%44 = insertelement <2 x double> poison, double %24, i64 0
%45 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
%46 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %11, <2 x double> %45, <2 x double> %43)
%47 = insertelement <2 x double> poison, double %13, i64 0
%48 = shufflevector <2 x double> %47, <2 x double> poison, <2 x i32> zeroinitializer
%49 = insertelement <2 x double> poison, double %26, i64 0
%50 = shufflevector <2 x double> %49, <2 x double> poison, <2 x i32> zeroinitializer
%51 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %48, <2 x double> %50, <2 x double> %46)
%52 = fmul <2 x double> %51, <double 2.000000e+00, double 2.000000e+00>
%53 = extractelement <2 x double> %8, i64 0
%54 = fmul double %53, %16
%55 = tail call double @llvm.fmuladd.f64(double %3, double %14, double %54)
%56 = tail call double @llvm.fmuladd.f64(double %5, double %18, double %55)
%57 = extractelement <2 x double> %8, i64 1
%58 = tail call double @llvm.fmuladd.f64(double %57, double %20, double %56)
%59 = tail call double @llvm.fmuladd.f64(double %39, double %22, double %58)
%60 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %59)
%61 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %60)
%62 = fmul double %61, 2.000000e+00
%63 = tail call double @llvm.fmuladd.f64(double %57, double %18, double %55)
%64 = tail call double @llvm.fmuladd.f64(double %5, double %20, double %63)
%65 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %64)
%66 = tail call double @llvm.fmuladd.f64(double %39, double %24, double %65)
%67 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %66)
%68 = fmul double %67, 2.000000e+00
%69 = fmul double %57, %16
%70 = tail call double @llvm.fmuladd.f64(double %3, double %14, double %69)
%71 = tail call double @llvm.fmuladd.f64(double %5, double %18, double %70)
%72 = tail call double @llvm.fmuladd.f64(double %53, double %20, double %71)
%73 = tail call double @llvm.fmuladd.f64(double %38, double %22, double %72)
%74 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %73)
%75 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %74)
%76 = fmul double %75, 2.000000e+00
%77 = tail call double @llvm.fmuladd.f64(double %53, double %18, double %70)
%78 = tail call double @llvm.fmuladd.f64(double %5, double %20, double %77)
%79 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %78)
%80 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %79)
%81 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %80)
%82 = fmul double %81, 2.000000e+00
%83 = fmul double %3, %16
%84 = tail call double @llvm.fmuladd.f64(double %5, double %14, double %83)
%85 = tail call double @llvm.fmuladd.f64(double %53, double %18, double %84)
%86 = tail call double @llvm.fmuladd.f64(double %57, double %20, double %85)
%87 = tail call double @llvm.fmuladd.f64(double %38, double %22, double %86)
%88 = tail call double @llvm.fmuladd.f64(double %39, double %24, double %87)
%89 = tail call double @llvm.fmuladd.f64(double %13, double %26, double %88)
%90 = fmul double %89, 2.000000e+00
%91 = tail call double @llvm.fmuladd.f64(double %57, double %18, double %84)
%92 = tail call double @llvm.fmuladd.f64(double %53, double %20, double %91)
%93 = tail call double @llvm.fmuladd.f64(double %39, double %22, double %92)
%94 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %93)
%95 = tail call double @llvm.fmuladd.f64(double %13, double %26, double %94)
%96 = fmul double %95, 2.000000e+00
%97 = tail call double @llvm.fmuladd.f64(double %5, double %14, double %54)
%98 = tail call double @llvm.fmuladd.f64(double %3, double %18, double %97)
%99 = tail call double @llvm.fmuladd.f64(double %57, double %20, double %98)
%100 = tail call double @llvm.fmuladd.f64(double %38, double %22, double %99)
%101 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %100)
%102 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %101)
%103 = fmul double %102, 2.000000e+00
%104 = tail call double @llvm.fmuladd.f64(double %57, double %18, double %97)
%105 = tail call double @llvm.fmuladd.f64(double %3, double %20, double %104)
%106 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %105)
%107 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %106)
%108 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %107)
%109 = fmul double %108, 2.000000e+00
%110 = tail call double @llvm.fmuladd.f64(double %5, double %14, double %69)
%111 = tail call double @llvm.fmuladd.f64(double %3, double %18, double %110)
%112 = tail call double @llvm.fmuladd.f64(double %53, double %20, double %111)
%113 = tail call double @llvm.fmuladd.f64(double %39, double %22, double %112)
%114 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %113)
%115 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %114)
%116 = fmul double %115, 2.000000e+00
%117 = tail call double @llvm.fmuladd.f64(double %53, double %18, double %110)
%118 = tail call double @llvm.fmuladd.f64(double %3, double %20, double %117)
%119 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %118)
%120 = tail call double @llvm.fmuladd.f64(double %39, double %24, double %119)
%121 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %120)
%122 = fmul double %121, 2.000000e+00
%123 = tail call double @llvm.fmuladd.f64(double %53, double %14, double %83)
%124 = tail call double @llvm.fmuladd.f64(double %5, double %18, double %123)
%125 = tail call double @llvm.fmuladd.f64(double %57, double %20, double %124)
%126 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %125)
%127 = tail call double @llvm.fmuladd.f64(double %39, double %24, double %126)
%128 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %127)
%129 = fmul double %128, 2.000000e+00
%130 = tail call double @llvm.fmuladd.f64(double %57, double %18, double %123)
%131 = tail call double @llvm.fmuladd.f64(double %5, double %20, double %130)
%132 = tail call double @llvm.fmuladd.f64(double %39, double %22, double %131)
%133 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %132)
%134 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %133)
%135 = fmul double %134, 2.000000e+00
%136 = tail call double @llvm.fmuladd.f64(double %53, double %14, double %27)
%137 = tail call double @llvm.fmuladd.f64(double %3, double %18, double %136)
%138 = tail call double @llvm.fmuladd.f64(double %57, double %20, double %137)
%139 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %138)
%140 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %139)
%141 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %140)
%142 = fmul double %141, 2.000000e+00
%143 = tail call double @llvm.fmuladd.f64(double %57, double %18, double %136)
%144 = tail call double @llvm.fmuladd.f64(double %3, double %20, double %143)
%145 = tail call double @llvm.fmuladd.f64(double %38, double %22, double %144)
%146 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %145)
%147 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %146)
%148 = fmul double %147, 2.000000e+00
%149 = tail call double @llvm.fmuladd.f64(double %53, double %14, double %69)
%150 = tail call double @llvm.fmuladd.f64(double %3, double %18, double %149)
%151 = tail call double @llvm.fmuladd.f64(double %5, double %20, double %150)
%152 = tail call double @llvm.fmuladd.f64(double %39, double %22, double %151)
%153 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %152)
%154 = tail call double @llvm.fmuladd.f64(double %13, double %26, double %153)
%155 = fmul double %154, 2.000000e+00
%156 = tail call double @llvm.fmuladd.f64(double %5, double %18, double %149)
%157 = tail call double @llvm.fmuladd.f64(double %3, double %20, double %156)
%158 = tail call double @llvm.fmuladd.f64(double %38, double %22, double %157)
%159 = tail call double @llvm.fmuladd.f64(double %39, double %24, double %158)
%160 = tail call double @llvm.fmuladd.f64(double %13, double %26, double %159)
%161 = fmul double %160, 2.000000e+00
%162 = tail call double @llvm.fmuladd.f64(double %57, double %14, double %83)
%163 = tail call double @llvm.fmuladd.f64(double %5, double %18, double %162)
%164 = tail call double @llvm.fmuladd.f64(double %53, double %20, double %163)
%165 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %164)
%166 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %165)
%167 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %166)
%168 = fmul double %167, 2.000000e+00
%169 = tail call double @llvm.fmuladd.f64(double %53, double %18, double %162)
%170 = tail call double @llvm.fmuladd.f64(double %5, double %20, double %169)
%171 = tail call double @llvm.fmuladd.f64(double %38, double %22, double %170)
%172 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %171)
%173 = tail call double @llvm.fmuladd.f64(double %39, double %26, double %172)
%174 = fmul double %173, 2.000000e+00
%175 = tail call double @llvm.fmuladd.f64(double %57, double %14, double %27)
%176 = tail call double @llvm.fmuladd.f64(double %3, double %18, double %175)
%177 = tail call double @llvm.fmuladd.f64(double %53, double %20, double %176)
%178 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %177)
%179 = tail call double @llvm.fmuladd.f64(double %39, double %24, double %178)
%180 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %179)
%181 = fmul double %180, 2.000000e+00
%182 = tail call double @llvm.fmuladd.f64(double %53, double %18, double %175)
%183 = tail call double @llvm.fmuladd.f64(double %3, double %20, double %182)
%184 = tail call double @llvm.fmuladd.f64(double %39, double %22, double %183)
%185 = tail call double @llvm.fmuladd.f64(double %13, double %24, double %184)
%186 = tail call double @llvm.fmuladd.f64(double %38, double %26, double %185)
%187 = fmul double %186, 2.000000e+00
%188 = tail call double @llvm.fmuladd.f64(double %57, double %14, double %54)
%189 = tail call double @llvm.fmuladd.f64(double %3, double %18, double %188)
%190 = tail call double @llvm.fmuladd.f64(double %5, double %20, double %189)
%191 = tail call double @llvm.fmuladd.f64(double %38, double %22, double %190)
%192 = tail call double @llvm.fmuladd.f64(double %39, double %24, double %191)
%193 = tail call double @llvm.fmuladd.f64(double %13, double %26, double %192)
%194 = fmul double %193, 2.000000e+00
%195 = tail call double @llvm.fmuladd.f64(double %5, double %18, double %188)
%196 = tail call double @llvm.fmuladd.f64(double %3, double %20, double %195)
%197 = tail call double @llvm.fmuladd.f64(double %39, double %22, double %196)
%198 = tail call double @llvm.fmuladd.f64(double %38, double %24, double %197)
%199 = tail call double @llvm.fmuladd.f64(double %13, double %26, double %198)
%200 = fmul double %199, 2.000000e+00
%201 = extractelement <2 x double> %52, i64 0
%202 = extractelement <2 x double> %52, i64 1
%203 = fcmp ogt double %201, %202
%204 = select i1 %203, double %201, double %202
%205 = fcmp ogt double %62, %204
%206 = select i1 %205, double %62, double %204
%207 = fcmp ogt double %68, %206
%208 = select i1 %207, double %68, double %206
%209 = fcmp ogt double %76, %208
%210 = select i1 %209, double %76, double %208
%211 = fcmp ogt double %82, %210
%212 = select i1 %211, double %82, double %210
%213 = fcmp ogt double %90, %212
%214 = select i1 %213, double %90, double %212
%215 = fcmp ogt double %96, %214
%216 = select i1 %215, double %96, double %214
%217 = fcmp ogt double %103, %216
%218 = select i1 %217, double %103, double %216
%219 = fcmp ogt double %109, %218
%220 = select i1 %219, double %109, double %218
%221 = fcmp ogt double %116, %220
%222 = select i1 %221, double %116, double %220
%223 = fcmp ogt double %122, %222
%224 = select i1 %223, double %122, double %222
%225 = fcmp ogt double %129, %224
%226 = select i1 %225, double %129, double %224
%227 = fcmp ogt double %135, %226
%228 = select i1 %227, double %135, double %226
%229 = fcmp ogt double %142, %228
%230 = select i1 %229, double %142, double %228
%231 = fcmp ogt double %148, %230
%232 = select i1 %231, double %148, double %230
%233 = fcmp ogt double %155, %232
%234 = select i1 %233, double %155, double %232
%235 = fcmp ogt double %161, %234
%236 = select i1 %235, double %161, double %234
%237 = fcmp ogt double %168, %236
%238 = select i1 %237, double %168, double %236
%239 = fcmp ogt double %174, %238
%240 = select i1 %239, double %174, double %238
%241 = fcmp ogt double %181, %240
%242 = select i1 %241, double %181, double %240
%243 = fcmp ogt double %187, %242
%244 = select i1 %243, double %187, double %242
%245 = fcmp ogt double %194, %244
%246 = select i1 %245, double %194, double %244
%247 = fcmp ogt double %200, %246
%248 = select i1 %247, double %200, double %246
%249 = fmul double %5, %5
%250 = tail call double @llvm.fmuladd.f64(double %3, double %3, double %249)
%251 = tail call double @llvm.fmuladd.f64(double %53, double %53, double %250)
%252 = tail call double @llvm.fmuladd.f64(double %57, double %57, double %251)
%253 = tail call double @llvm.fmuladd.f64(double %39, double %39, double %252)
%254 = tail call double @llvm.fmuladd.f64(double %38, double %38, double %253)
%255 = tail call double @llvm.fmuladd.f64(double %13, double %13, double %254)
%256 = tail call double @llvm.fmuladd.f64(double %14, double %14, double %255)
%257 = tail call double @llvm.fmuladd.f64(double %16, double %16, double %256)
%258 = tail call double @llvm.fmuladd.f64(double %18, double %18, double %257)
%259 = tail call double @llvm.fmuladd.f64(double %20, double %20, double %258)
%260 = tail call double @llvm.fmuladd.f64(double %22, double %22, double %259)
%261 = tail call double @llvm.fmuladd.f64(double %24, double %24, double %260)
%262 = tail call double @llvm.fmuladd.f64(double %26, double %26, double %261)
%263 = fsub double %262, %248
%264 = tail call double @llvm.fabs.f64(double %263)
ret double %264
}