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


x86 assembly (clang, -O0):
<s61234distsq>:
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    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1d25(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1c7f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1bd9(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1b33(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1a8d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x19e7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1941(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x189b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x17f5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x174f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x16a9(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1603(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x155d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x14ba(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1417(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1374(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x12d1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x122e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x118b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10e8(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1045(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xfa2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xeff(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe5c(%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    221a <s61234distsq+0x111a>
movslq -0xe4(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x20(%rbp),%xmm0
jbe    2201 <s61234distsq+0x1101>
movslq -0xe4(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x20(%rbp)
jmp    2206 <s61234distsq+0x1106>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    21c4 <s61234distsq+0x10c4>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    2234 <s61234distsq+0x1134>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movaps 0xdcb(%rip),%xmm1
pand   %xmm1,%xmm0
add    $0x70,%rsp
pop    %rbp
ret

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

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

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